richtext 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a41039f175ce7ee67d507040de2a1c84f58c9069
+  data.tar.gz: 60ae51774de4953ea1b5e59ef3ffb8afd2f520ac
+SHA512:
+  metadata.gz: 86924ff26a091d4087245467c47e43aabd5499eb8fc785ac2ba8b2dbca596ab49d9ba79399ad6c51e65c6f629fb9ba38e6d02cd8725845f9a6c1d0ffe84f70a6
+  data.tar.gz: 8e08c49fcb57d006235eaa58258b9e0dc0b0e0e5a753594b15becda8b7715413ce6a9b0ef5f5bea8be0a1075e05902d6dad5194e87635b9d34a5dd51432dac42

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in richtext.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sebastian Lindberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# Richtext
+
+This gem is intended to simplify the handling of formatted text. Out of the box there is no support for any actual format, but that is intentional. The RichText::Document class is primarily ment to be subclassed and extended, and only includes functionality that is (potentially) useful to any format.
+
+See _Usage_ below for more details on how to work with and extend the gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'richtext'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install richtext
+
+## Usage
+
+```ruby
+# Create a new RichText document
+rt = RichText::Document.new 'hello '
+
+# Or use the more convenient method
+rt = RichText 'hello '
+
+# Format the text using attributes
+entry = rt.append('world', bold: true, my_attribute: '.')
+
+# Some common styling attributes are supported directly
+# This line is equivalent to entry[:italic] = true
+entry.italic = true
+# Under the covers the attributes are stored as 
+# key-value pairs, so any attribute is valid
+entry[:my_attribute] = '!'
+
+# Render the text without any formatting
+puts rt.to_s # => 'hello world'
+
+# Or style the text yourself
+html = rt.to_s do |entry, string|
+  # Access the attributes from the entry and format the
+  # string accordingly
+  string += entry[:my_attribute] if entry[:my_attribute]
+  string = "<b>#{string}</b>" if entry.bold?
+  
+  # Return the formatted string at the end of the block
+  string
+end
+
+puts html # => 'hello <b>world!</b>'
+```
+
+Implementing new formats is easy. Just extend the `RichText::Document` class and implement the class methods `.parse` and `.render`. The following snippet describes a document type that only renders words with more than 6 letters.
+
+```ruby
+class MyFormat < RichText::Document
+  # Use this method to signal if the document needs to be
+  # parsed, or if its raw form will work.
+  def should_parse?
+    true
+  end
+
+  def self.parse string
+    base = RichText::Document::Entry.new
+    # Format specific implementation to parse a string. Here
+    # each word is represented by its own entry. Entries are
+    # given a random visibility attribute.
+    string.split(' ').each do |word|
+      entry = RichText::Document::Entry.new word, visible: (word.length > 6)
+      base.add entry
+    end
+    base
+  end
+
+  def self.render base
+    # Format specific implementation to render the document
+    base.to_s do |entry, string|
+      next string unless entry.leaf?
+      entry[:visible] ? string + ' ' : ''
+    end.rstrip!
+  end
+end
+
+doc = MyFormat.new 'Format specific implementation to parse a string'
+puts doc.to_s # => 'specific implementation'
+
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/seblindberg/richtext.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "richtext"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/richtext/document/entry.rb

@@ -0,0 +1,142 @@
+# Entry
+#
+# The Entry class extends the basic Node class and adds methods that make 
+# handling text a little nicer. Essentially the :text attribute is given special
+# status by allowing it to a) be set during initialization, b) only visible in 
+# leaf nodes and c) copied over when adding children to leaf nodes.
+#
+# Some attributes are also supported explicitly by the inclusion of special 
+# accesser methods. The attributes are are bold, italic, underline, color and 
+# font.
+
+module RichText
+  class Document
+    class Entry < Node
+      
+      # Initialize
+      #
+      # Extend the default Node initializer by also accepting a string. It will, 
+      # if given, be stored as a text attribute.
+      
+      def initialize text = nil, **attributes
+        super attributes
+        self[:text] = text if text
+      end
+      
+      
+      # Text
+      #
+      # Read the text of the node. This will return nil unless the node is a 
+      # leaf node. Note that nodes that are not leafs can have the text entry, 
+      # but it is discouraged by dissalowing access using this method.
+      
+      def text
+        if leaf?
+          self[:text] || ''
+        else
+          nil
+        end
+      end
+      
+      
+      # Add child
+      #
+      # A child is either another node or any object that respond to #to_s.
+      
+      def add *new_children
+        if leaf?
+          # Remove the text entry from the node and put it in a new leaf node 
+          # among the children, unless it is empty
+          if t = @attributes.delete(:text)
+            new_children.unshift self.class.new(t) unless t.empty?
+          end
+        end
+        
+        super
+      end
+      
+      alias_method :<<, :add
+      
+      
+      # To String
+      #
+      # Combine the text from all the leaf nodes in the tree, from left to 
+      # right. If a block is given the node, along with its text will be passed 
+      # as arguments. The block will be called recursivly, starting at the leaf 
+      # nodes and propagating up until the entire tree has been "rendered" in 
+      # this way.
+      
+      def to_s &block
+        string = leaf? ? 
+          text : 
+          @children.reduce('') {|str, child| str + child.to_s(&block) }
+          
+        block_given? ? yield(self, string) : string
+      end
+      
+      
+      # Supported Text Attributes
+      #
+      
+      
+      # Bold
+      #
+      
+      def bold?
+        self[:bold]
+      end
+      
+      def bold= b
+        self[:bold] = b ? true : false
+      end
+      
+      
+      # Italic
+      #
+      
+      def italic?
+        self[:italic]
+      end
+      
+      def italic= i
+        self[:italic] = i ? true : false
+      end
+      
+      
+      # Underline
+      #
+      
+      def underline?
+        self[:underline]
+      end
+      
+      def underline= u
+        self[:underline] = u ? true : false
+      end
+      
+      
+      # Color
+      #
+      
+      def color
+        self[:color]
+      end
+      
+      def color= c
+        self[:color] = c
+      end
+      
+      
+      # Font
+      #
+      
+      def font
+        self[:font]
+      end
+      
+      def font= f
+        self[:font] = f
+      end
+    end
+  end
+end

data/lib/richtext/document.rb

@@ -0,0 +1,180 @@
+module RichText
+  class Document
+    # Initialize
+    #
+    # Create a new RichText Document, either from a string or from an existing 
+    # ducument. That feature is particularly useful when converting between 
+    # formats.
+    #
+    # When given a string or a RichText Document of the same class no parsing is 
+    # performed. Only when given a document of a different subclass will the 
+    # parser need to be run parsed. Note that the document(s) may already be in  
+    # parsed form, in which case no further parsing is performed. See #base for 
+    # more details.
+    
+    def initialize arg = ''
+      @base, @raw = if self.class == arg.class
+        arg.parsed? ?
+          [arg.base, nil] :
+          [nil, arg.raw]
+      elsif Document === arg
+        # For any other RichText object we take the base node
+        [arg.base, nil]
+      elsif Entry === arg
+        # Also accept an Entry which will be used as the
+        # document base
+        [arg, nil]
+      else
+        [nil, arg.to_s]
+      end
+    end
+    
+    
+    # To String
+    #
+    # Use the static implementation of .render to convert the document back into
+    # a string. If the document was never parsed (and is unchanged) the 
+    # origninal string is just returned.
+    #
+    # If a block is given it will be used in place of .render to format the node 
+    # tree.
+    
+    def to_s &block
+      if block_given?
+        base.to_s(&block)
+      elsif parsed? || should_parse?
+        self.class.render base
+      else
+        @raw
+      end
+    end
+    
+    
+    # Add (+)
+    #
+    # Add this RichText to another.
+    
+    def + other
+      # If the other object is of the same class, and neither
+      # one of the texts have been parsed, we can concatenate
+      # the raw inputs together
+      if other.class == self.class && !parsed? && !other.parsed?
+        return self.class.new (@raw + other.raw)
+      end
+      
+      # Same root class
+      if Document === other
+        return self.class.new (base + other.base)
+      end
+      
+      unless other.respond_to?(:to_s)
+        raise TypeError,
+          "cannot add #{other.class.name} to #{self.class.name}"
+      end
+      
+      # Assume that the input is a raw string of the same
+      # class as the current RichText object and wrap it
+      # before adding it
+      self + self.class.new(other)
+    end
+    
+    
+    def append string, **attributes
+      node = Entry.new(string, **attributes)
+      base.add node
+      node
+    end
+    
+    
+    # Base
+    #
+    # Getter for the base node. If the raw input has not yet been 
+    # parsed that will happen first, before the base node is returned.
+    
+    def base
+      unless @base
+        @base = Entry.new
+        self.class.parse @base, @raw
+        @raw  = nil # Free the cached string
+      end
+      
+      @base
+    end
+    
+    alias_method :root, :base
+    
+    
+    # Raw
+    #
+    # Protected getter for the raw input.
+    
+    protected def raw
+      @raw
+    end
+    
+    
+    # Parsed?
+    #
+    # Returns true if the raw input has been parsed and the internal 
+    # representation is now a tree of nodes.
+    
+    def parsed?
+      @raw.nil?
+    end
+    
+    
+    protected def should_parse?
+      false
+    end
+    
+    
+    # Each Node
+    #
+    # Iterate over all Entry nodes in the document tree.
+    
+    def each_node &block
+      base.each(&block)
+    end
+    
+    alias_method :each_entry, :each_node
+    
+    
+    # Parse
+    #
+    # Document type specific method for parsing a string and turning it into a 
+    # tree of entry nodes. This method is intended to be overridden when the 
+    # Document is subclassed. The default implementation just creates a top 
+    # level Entry containing the given string.
+    
+    def self.parse base, string
+      base[:text] = string
+    end
+    
+    
+    # Render
+    #
+    # Document type specific method for rendering a tree of entry nodes. This 
+    # method is intended to be overridden when the Document is subclassed. The 
+    # default implementation just concatenates the text entries into.
+    
+    def self.render base
+      base.to_s
+    end
+    
+    
+    # From
+    #
+    # Convenience method for instansiating one RichText object from another. The 
+    # methods only purpose is to make that intent more clear, and to make the 
+    # creation from another RichText object explicit.
+    
+    def self.from doc
+      unless Document === doc
+        raise TypeError, 
+            "Can only create a #{self.name} from other RichText objects"
+      end
+          
+      self.new doc
+    end
+  end
+end

data/lib/richtext/node.rb

@@ -0,0 +1,234 @@
+# Node
+#
+# A Node can have  children, which themselvs can have children. A tree like 
+# structure can thus be formed by composing multiple Nodes. An example of such a 
+# tree structure can be seen below.
+#
+# The Node class implements some convenience methods for iterating, left to 
+# right, over either all
+#  - nodes in the tree
+#  - leafs in the tree
+#  - direct decendant of a node
+#
+# In addition to having children a Node can also have attributes, represented by # simple key => value pairs.
+#
+#                Example Tree
+#                                        +--------------------------+
+#                     A <- Root Node     | Left to right order: ABC |
+#                    / \                 +--------------------------+
+#      Leaf Node -> B   C <- Child to A
+#    (no children)     /|\
+#                      ...
+# 
+
+module RichText
+  class Node
+    include Enumerable
+    
+    attr_reader :attributes
+    
+    def initialize **attributes
+      @children   = []
+      @attributes = attributes
+      #@attributes[:text] = text if text
+    end
+    
+    
+    def initialize_copy original
+      @children   = original.children.map(&:dup)
+      @attributes = original.attributes.dup
+    end
+    
+    
+    # Leaf?
+    #
+    # Returns true if this node a leaf (childless) node.
+    
+    def leaf?
+      @children.empty?
+    end
+    
+    
+    # Children
+    #
+    # Protected accessor for the children array. This array should never be 
+    # mutated from the outside and is only protected rather than private to be
+    # accessable to ther Nodes.
+    
+    protected def children
+      @children
+    end
+    
+    
+    # Add child
+    #
+    # A child is either another node or any object that respond to #to_s.
+    
+    def add *new_children
+      new_children.each do |c|
+        @children << ((Node === c) ? c : self.class.new(c))
+      end
+
+      @children
+    end
+    
+    alias_method :<<, :add
+    
+    
+    # Add (+)
+    #
+    # Combines two nodes by creating a new root and adding the two as children.
+    
+    def + other
+      self.class.new.tap {|root| root.add self, other }
+    end
+    
+    
+    # Each
+    #
+    # Iterate over each node in the tree, including self.
+    
+    def each &block
+      return to_enum(__callee__) unless block_given?
+      
+      yield self
+            
+      @children.each do |child|
+        yield child
+        child.each(&block) unless child.leaf?
+      end
+    end
+    
+    
+    # Each Leaf
+    #
+    # Iterate over each leaf in the tree. This method will yield the leaf nodes 
+    # of the tree from left to right.
+    
+    def each_leaf &block
+      return to_enum(__callee__) unless block_given?
+      return yield self if leaf?
+      
+      @children.each do |child|
+        if child.leaf?
+          yield child
+        else
+          child.each_leaf(&block)
+        end
+      end
+    end
+    
+    
+    # Each child
+    #
+    # Iterate over the children of this node.
+    
+    def each_child &block
+      @children.each(&block)
+    end
+    
+    
+    # Attribute accessor
+    #
+    # Read and write an attribute of the node. Attributes are simply key-value 
+    # pairs stored internally in a hash.
+    
+    def [] attribute
+      @attributes[attribute]
+    end
+    
+    def []= attribute, value
+      @attributes[attribute] = value
+    end
+    
+    
+    # Count
+    #
+    # Returns the child count of this node.
+    
+    def count
+      @children.size
+    end
+    
+    
+    # Size
+    #
+    # Returns the size of the tree where this node is the root.
+    
+    def size
+      @children.reduce(1) {|total, child| total + child.size }
+    end
+    
+    
+    # Minimal?
+    #
+    # Test if the tree under this node is minimal or not. A non minimal tree 
+    # contains children which themselvs only have one child.
+    
+    def minimal?
+      all? {|node| node.count != 1 }
+    end
+    
+    
+    # Optimize!
+    #
+    # Go through each child and merge any node that a) is not a lead node and b) 
+    # only has one child, with its child. The attributes of the child will 
+    # override those of the parent.
+    
+    def optimize!
+      # If the node is a leaf it cannot be optimized further
+      return if leaf?
+      
+      # First optimize each of the children
+      @children.map(&:optimize!)
+      
+      # If we only have one child it is superfluous and
+      # should be merged. That means this node will inherrit
+      # the children of the single child as well as its
+      # attributes
+      if count == 1
+        child = @children[0]
+        # Move the children over
+        @children = child.children
+        @attributes.merge! child.attributes
+      end
+    end
+    
+    
+    # Shallow equality (exclude children)
+    #
+    # Returns true if the other node has the exact same attributes.
+    
+    def === other
+      @attributes == other.attributes
+    end
+    
+    
+    # Deep equality (include children)
+    #
+    # Returns true if the other node has the same attributes and its children 
+    # are also identical.
+    
+    def == other
+      # First make sure the nodes child count matches
+      return false unless count == other.count
+      
+      # The nodes are not equal if their attributes do not
+      # match
+      return false unless self === other
+      
+      # Lastly make sure all of the children are equal
+      each_child.zip(other.each_child).all? {|c| c[0] == c[1] }
+    end
+    
+    
+    def inspect
+      children = @children.reduce(''){|s, c| 
+          s + "\n" + c.inspect.gsub(/(^)/) { $1 + '  ' }}
+          
+      "#<%{name} %<a>p:%<id>#x>%{children}" % {
+          name: self.class.name, id: self.object_id, a: @attributes, children: children}
+    end
+  end
+end

data/lib/richtext/version.rb

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

data/lib/richtext.rb

@@ -0,0 +1,18 @@
+require 'richtext/version'
+require 'richtext/node'
+require 'richtext/document/entry'
+require 'richtext/document'
+
+module RichText  
+  
+end
+
+
+# RichText
+#
+# Convenience method for creating RichText objects. Calling RichText(obj) is 
+# equivalent to RichText::Document.new(obj).
+
+def RichText string
+  RichText::Document.new string
+end

data/richtext.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'richtext/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "richtext"
+  spec.version       = RichText::VERSION
+  spec.authors       = ["Sebastian Lindberg"]
+  spec.email         = ["seb.lindberg@gmail.com"]
+
+  spec.summary       = %q{This gem provides a basic way of representing formatting within strings.}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/seblindberg/ruby-richtext"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: richtext
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sebastian Lindberg
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-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.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- seb.lindberg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/richtext.rb
+- lib/richtext/document.rb
+- lib/richtext/document/entry.rb
+- lib/richtext/node.rb
+- lib/richtext/version.rb
+- richtext.gemspec
+homepage: https://github.com/seblindberg/ruby-richtext
+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.5.1
+signing_key: 
+specification_version: 4
+summary: This gem provides a basic way of representing formatting within strings.
+test_files: []