xmlish 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+xmlish
+======
+
+String interpolation from xml-like text.
+
+Usage Examples
+--------------
+
+A simple example
+
+```ruby
+template = "Press <red><bold>ENTER</bold></red> or <bold><red>ESC</red></bold>"
+callbacks = {
+  'red' => lambda { |str| "$#{str}$" },
+  'bold' => lambda { |str| "**#{str}**" }
+}
+Xmlish.parse(template, callbacks) #=> "Press $**ENTER**$ or **$ESC$**"
+```
+
+See spec directory for more examples.

data/lib/xmlish.rb

@@ -0,0 +1,199 @@
+module Xmlish
+
+  # @param str [String]
+  # @param callbacks [Array<#call>]
+  # @return [String]
+  def self.parse str, callbacks=nil
+    reconstruct_from_nodes parse_to_nodes(str, callbacks.keys), callbacks
+  end
+
+  # @param str [String]
+  # @param callbacks [Array<#call>]
+  # @return [void]
+  def self.walk str, callbacks=nil
+    walk_nodes parse_to_nodes(str, callbacks.keys), callbacks
+  end
+
+  private
+
+  # @param str [String]
+  # @return [Array<Node>]
+  def self.parse_to_nodes str, tag_names
+    Parser.new(str, tag_names).parse
+  end
+
+  # @param nodes [Array<Node>]
+  # @param callbacks [Array<#call>]
+  # @return [String]
+  def self.reconstruct_from_nodes nodes, callbacks={}
+    Reconstructor.new(nodes, callbacks).reconstruct
+  end
+
+  # @param nodes [Array<Node>]
+  # @param callbacks [Array<#call>]
+  # @return [void]
+  def self.walk_nodes nodes, callbacks={}
+    Walker.new(nodes, callbacks).walk
+  end
+
+  class Node < Struct.new(:nodes, :attr_name)
+  end
+
+  class Parser
+    def initialize str, tag_names
+      @str = str
+      @tag_names = tag_names
+    end
+
+    def parse
+      normalise(parse_string @str)
+    end
+
+    private
+
+    # @param s [String] like "Press <red>e</red> to edit"
+    def parse_string s
+      [].tap do |nodes|
+        while s.length > 0
+          head, tag_name = nil, nil
+          begin
+            head, tag_name = (m=s.match(/[^<]*<([A-Za-z0-9]+)>/)).to_a
+          end until tag_name.nil? || begin
+            @tag_names.include?(tag_name).tap do |incl|
+              unless incl
+                nodes << head
+                s = s[head.length, s.length]
+              end
+            end
+          end
+          if tag_name.nil?
+            nodes << s
+            break
+          end
+          text = head[0, head.length - tag_name.length - '<>'.length]
+          nodes << text unless text.length == 0
+          s = s[head.length, s.length]
+          head = s.match(/.*?<\/#{tag_name}>/).to_a.first
+          node_text = head[0, head.length - tag_name.length - '</>'.length]
+          node_text = parse_string(node_text)
+          nodes << Node.new(node_text, tag_name)
+          s = s[head.length, s.length]
+        end
+      end
+    end
+
+    # @param nodes [Array<Node,String>]
+    # @return [Array<Node,String>]
+    def normalise nodes
+      nodes.each do |node|
+        if Node === node
+          node.nodes = join_adjacent_strings node.nodes
+          normalise node.nodes
+        end
+      end
+    end
+
+    # @param nodes [Array<Node,String>]
+    # @return [Array<Node,String>]
+    def join_adjacent_strings nodes
+      nodes.inject [] do |a, b|
+        if b.is_a?(String) && a.last.is_a?(String)
+          (a[0, a.length-1] + ["#{a.last}#{b}"])
+        else
+          [a, b]
+        end.flatten
+      end
+    end
+  end
+
+  class Reconstructor
+    # @param nodes [Array<Node>]
+    # @param callbacks [Array<#call>]
+    def initialize nodes, callbacks
+      @nodes = nodes
+      @callbacks = callbacks
+    end
+
+    # @return [String]
+    def reconstruct nodes=@nodes
+      nodes.collect do |node|
+        if Node === node
+          callback = callback_for_tag node.attr_name
+          if callback
+            callback.call(reconstruct node.nodes)
+          else
+            reconstruct node.nodes
+          end
+        else
+          callback = callback_for_tag 'text'
+          if callback
+            callback.call(node)
+          else
+            node
+          end
+        end
+      end.join('')
+    end
+
+    private
+
+    def callback_for_tag tag
+      if @callbacks.has_key? tag
+        @callbacks[tag] || identity_callback
+      else
+        nil
+      end
+    end
+
+    def identity_callback
+      lambda{|s|s}
+    end
+
+  end
+
+  class Walker
+    # @param nodes [Array<Node>]
+    # @param callbacks [Array<#call>]
+    def initialize nodes, callbacks
+      @nodes = nodes
+      @callbacks = callbacks
+    end
+
+    # @return [String]
+    def walk nodes=@nodes
+      nodes.collect do |node|
+        if Node === node
+          callback = callback_for_tag node.attr_name
+          if callback
+            callback.call(Proc.new{walk node.nodes})
+          else
+            walk node.nodes
+          end
+        else
+          callback = callback_for_tag 'text'
+          if callback
+            callback.call(Proc.new{node})
+          else
+            node
+          end
+        end
+      end.join('')
+    end
+
+    private
+
+    def callback_for_tag tag
+      if @callbacks.has_key? tag
+        @callbacks[tag] || identity_callback
+      else
+        nil
+      end
+    end
+
+    def identity_callback
+      lambda{|s|s.call}
+    end
+
+  end
+
+end

data/spec/example_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Xmlish do
+
+  describe ".parse" do
+    specify "repeated nested tags" do
+      template = "Press <red><bold>ENTER</bold></red> or <bold><red>ESC</red></bold>"
+      callbacks = {
+        'red' => lambda{|str|"$#{str}$"},
+        'bold' => lambda{|str|"**#{str}**"}
+      }
+      Xmlish.parse(template, callbacks).should == 'Press $**ENTER**$ or **$ESC$**'
+    end
+
+    specify "more complex repeated nested tags" do
+      template = "Press <red><u><</u><bold><downcase>ENTER</downcase></bold><u>></u></red> or <bold><red>ESC</red></bold>"
+      callbacks = {
+        'red' => lambda{|str|"$#{str}$"},
+        'bold' => lambda{|str|"**#{str}**"},
+        'u' => lambda{|str|"_#{str}_"},
+        'downcase' => lambda{|str|str.downcase},
+      }
+      Xmlish.parse(template, callbacks).should == 'Press $_<_**enter**_>_$ or **$ESC$**'
+    end
+
+    specify "plain text callbacks" do
+      template = "Press <red>ENTER</red> or <red>ESC</red>"
+      callbacks = {
+        'red' => lambda{|str|"$#{str}$"},
+        'text' => lambda{|str|"(#{str.upcase})"},
+      }
+      Xmlish.parse(template, callbacks).should == '(PRESS )$(ENTER)$( OR )$(ESC)$'
+    end
+
+    it "should leave tags without callback intact" do
+      template = "Press <red><bold>ENTER</bold></red> or <bold><red>ESC</red></bold>"
+      callbacks = {
+        'red' => lambda{|str|"$#{str}$"}
+      }
+      Xmlish.parse(template, callbacks).should == 'Press $<bold>ENTER</bold>$ or <bold>$ESC$</bold>'
+    end
+
+    it "should tolerate bad syntax in tags without callbacks" do
+      template = "Press <red>ENTER</bold></red> or <bold><red>ESC</red></penguins></>"
+      callbacks = {
+        'red' => lambda{|str|"$#{str}$"}
+      }
+      Xmlish.parse(template, callbacks).should == 'Press $ENTER</bold>$ or <bold>$ESC$</penguins></>'
+    end
+  end
+
+  describe ".walk" do
+    specify "building output in application" do
+      template = "Press <red>ENTER</red> or <red>ESC</red>"
+      output = []
+      callbacks = {
+        'red' => lambda{|str|
+          output << "{red-on}"
+          str.call
+          output << "{red-off}"
+        },
+        'text' => lambda{|str|
+          output << str.call.upcase
+        },
+      }
+      Xmlish.walk(template, callbacks)
+      output.join("").should == 'PRESS {red-on}ENTER{red-off} OR {red-on}ESC{red-off}'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'xmlish'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/xmlish_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Xmlish do
+
+  Node = Xmlish::Node
+
+  describe "#parse_to_nodes" do
+
+    def parse_to_nodes *args
+      Xmlish.send(:parse_to_nodes, *args)
+    end
+
+    specify "plain text" do
+      parse_to_nodes("test", []).should == ["test"]
+    end
+
+    specify "single tag" do
+      parse_to_nodes("Press <red>ENTER</red>", ['red']).should ==
+        ["Press ", Node.new(["ENTER"], 'red')]
+      parse_to_nodes("Press <bold>ENTER</bold>", ['bold']).should ==
+        ["Press ", Node.new(["ENTER"], 'bold')]
+    end
+
+    specify "nested tags" do
+      parse_to_nodes("Press <red><bold>ENTER</bold></red>", ['red', 'bold']).should ==
+        ["Press ", Node.new([Node.new(["ENTER"], 'bold')], 'red')]
+    end
+
+    specify "repeated tag" do
+      parse_to_nodes("Press <red>ENTER</red> or <red>ESC</red>", ['red']).should ==
+        ["Press ", Node.new(["ENTER"], 'red'), " or ", Node.new(["ESC"], 'red')]
+    end
+
+    specify "repeated nested tags" do
+      parse_to_nodes("Press <red><bold>ENTER</bold></red> or <red><bold>ESC</bold></red>", ['red', 'bold']).should ==
+        ["Press ", Node.new([Node.new(["ENTER"], 'bold')], 'red'), " or ", Node.new([Node.new(["ESC"], 'bold')], 'red')]
+    end
+
+    specify "non-listed tags pass through like normal text" do
+      parse_to_nodes("Press <red><bold>ENTER</bold></red> or <bold><red>ESC</red></bold>", ['red']).should ==
+        ["Press ", Node.new(["<bold>ENTER</bold>"], 'red'), " or <bold>", Node.new(["ESC"], 'red'), "</bold>"]
+    end
+  end
+
+  describe "#reconstruct_from_nodes" do
+
+    def reconstruct_from_nodes *args
+      Xmlish.send(:reconstruct_from_nodes, *args)
+    end
+
+    specify "only string nodes" do
+      reconstruct_from_nodes(["test"]).should == "test"
+    end
+
+    context "with null callbacks" do
+      specify "single tag" do
+        nodes = ["Press ", Node.new(["ENTER"], 'red')]
+        callbacks = {'red' => nil}
+        reconstruct_from_nodes(nodes).should == 'Press ENTER'
+      end
+
+      specify "nested tags" do
+        nodes = ["Press ", Node.new([Node.new(["ENTER"], 'bold')], 'red')]
+        callbacks = {'red' => nil, 'bold' => nil}
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press ENTER'
+      end
+
+      specify "repeated tag" do
+        nodes = ["Press ", Node.new(["ENTER"], 'red'), " or ", Node.new(["ESC"], 'red')]
+        callbacks = {'red' => nil}
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press ENTER or ESC'
+      end
+
+      specify "repeated nested tags" do
+        nodes = ["Press ", Node.new([Node.new(["ENTER"], 'bold')], 'red'), " or ", Node.new([Node.new(["ESC"], 'bold')], 'red')]
+        callbacks = {'red' => nil, 'bold' => nil}
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press ENTER or ESC'
+      end
+    end
+
+    context "with modifying callbacks" do
+      specify "single tag" do
+        nodes = ["Press ", Node.new(["ENTER"], 'red')]
+        callbacks = {'red' => lambda{|str|"$#{str}$"}}
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press $ENTER$'
+      end
+
+      specify "nested tags" do
+        nodes = ["Press ", Node.new([Node.new(["ENTER"], 'bold')], 'red')]
+        callbacks = {
+          'red' => lambda{|str|"$#{str}$"},
+          'bold' => lambda{|str|"**#{str}**"}
+        }
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press $**ENTER**$'
+      end
+
+      specify "repeated tag" do
+        nodes = ["Press ", Node.new(["ENTER"], 'red'), " or ", Node.new(["ESC"], 'red')]
+        callbacks = {'red' => lambda{|str|"$#{str}$"}}
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press $ENTER$ or $ESC$'
+      end
+
+      specify "repeated nested tags" do
+        nodes = ["Press ", Node.new([Node.new(["ENTER"], 'bold')], 'red'), " or ", Node.new([Node.new(["ESC"], 'bold')], 'red')]
+        callbacks = {
+          'red' => lambda{|str|"$#{str}$"},
+          'bold' => lambda{|str|"**#{str}**"}
+        }
+        reconstruct_from_nodes(nodes, callbacks).should == 'Press $**ENTER**$ or $**ESC**$'
+      end
+    end
+
+  end
+
+end

data/xmlish.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "xmlish"
+  s.version     = "0.0.1"
+  s.authors     = ["Joel Plane"]
+  s.email       = ["joel.plane@gmail.com"]
+  s.homepage    = "https://github.com/joelplane/xmlish"
+  s.summary     = %q{string interpolation from xml-like text}
+  s.description = %q{small almost-xml parser for complex string interpolation}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: xmlish
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joel Plane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: small almost-xml parser for complex string interpolation
+email:
+- joel.plane@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- lib/xmlish.rb
+- spec/example_spec.rb
+- spec/spec_helper.rb
+- spec/xmlish_spec.rb
+- xmlish.gemspec
+homepage: https://github.com/joelplane/xmlish
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: string interpolation from xml-like text
+test_files:
+- spec/example_spec.rb
+- spec/spec_helper.rb
+- spec/xmlish_spec.rb