bbsexp 0.2.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012, David Kahn
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,28 @@
+Library for making bbcode like markup for message boards.
+
+Look at test.rb and below for example usage.
+
+
+You can define your own elements and chain them together, but they can only be 1 character:
+
+    "[biu]bold italic underline[.]" => "<strong><em><u>bold italic underline</u></em></strong>
+
+you can also close multiple tags at once:
+
+    "[b][i][u]bold italic underline[...]" => "<strong><em><u>bold italic underline</u></em></strong>"
+
+unclosed tags are automatically closed at the end of the text:
+
+    "[b][i][u]bold italic underline" => "<strong><em><u>bold italic underline</u></em></strong>"
+
+Redundant elements are automatically ignored:
+
+    "[bbiiuu][b][i][u][b][i][u]text" => "<strong><em><u>text</u></em></strong>"
+
+The compiler follows rules such as not allowing block elements to be inside of inline elements:
+
+    "[i][q]q is blockquote" => "<em>q is blockquote</em>"
+
+you can also define custom functions to operate on the tags:
+
+    "[r]reversed[.]" => "desrever"

data/lib/bbsexp.rb

@@ -0,0 +1,4 @@
+require "strscan"
+require_relative "bbsexp/dialect"
+require_relative "bbsexp/expression"
+require_relative "bbsexp/compiler"

data/lib/bbsexp/compiler.rb

@@ -0,0 +1,88 @@
+module BBSexp
+  class Compiler
+    def initialize(parser, text)
+      @parser = parser
+      @text = text
+      @result = ''
+      @stack = []
+      @func_stack = []
+      @state = [3]
+      @locks = Hash[ @parser.exps.keys.map{|k| [k, false] } ]
+    end
+
+    def build
+      @result <<  tokens.map do |type, value|
+                    case type
+                    when :string  then eval_string value
+                    when :exp     then eval_exp value
+                    end
+                  end.join
+
+      # close unclosed expressions
+      @result << @stack.reverse.map {|token|
+                  token.reverse.map {|exp|
+                    @parser.exps[exp].tags.last }.join }.join
+    end
+
+    def tokens
+      return to_enum(:tokens) unless block_given?
+      scanner = StringScanner.new(@text)
+
+      while string = scanner.scan_until(@parser.regexp) 
+       exp = scanner.matched
+       yield [:string, string[0..-(exp.size + 1)]] unless string == exp
+       yield [:exp, exp[1..-2]]
+      end
+      yield [:string, scanner.rest] unless scanner.eos?
+    end
+
+    def eval_string(string)
+      # run callbacks on string
+      @func_stack.reduce(string) {|memo, func| func.(memo) }
+    end
+
+    def eval_exp(exp)
+      # dont parse if we are in the no parse zone
+      return eval_string(@parser.brackets(exp)) if @state.last == 0 and not exp.include? @parser.no_parse
+      # process expressions
+      unless exp[0] == @parser.end_exp
+        register(exp)  #returns start tags
+      else
+        terminate(exp) #returns end tags
+      end
+    end
+
+    def register(token)
+      @stack << active_exps =               # append valid expressions to the stack
+      token.chars.to_a.uniq.select do |exp| # ignore redundant and illegal expressions 
+        @locks[exp] == false and @parser.exps[exp] <= @state.last
+      end.sort do |a,b|
+        @parser.exps[b] <=> @parser.exps[a] # sort nocode > block > inline
+      end.map do |exp|
+        @locks[exp] = true                  # lock this expression to prevent its use deeper in the stack
+        @state << @parser.exps[exp].state   # set parser state to current element's level
+        exp                                 # return to token.active_exps as a valid expression
+      end
+      
+      @func_stack += active_exps.map {|exp| @parser.exps[exp].block }.compact
+
+      # return the start tags for the token
+      active_exps.map {|exp| @parser.exps[exp].tags.first }.join
+    end
+
+    def terminate(token) 
+      return @parser.brackets(token) if @stack.empty? # don't do anything if the stack is empty
+
+      token.chars.map do |close|
+        if exps = @stack.pop
+          exps.map do |exp|
+            @locks[exp] = false                        # unlock this expression so it can be used again
+            @state.pop                                 # return parser state to parent scope
+            @func_stack.pop if @parser.exps[exp].block # disable function
+            @parser.exps[exp].tags.last                # return end tag
+          end.reverse.join
+        end
+      end.join
+    end
+  end
+end

data/lib/bbsexp/dialect.rb

@@ -0,0 +1,57 @@
+module BBSexp
+  module Dialect
+    module ClassMethods
+      attr_accessor :exps, :brackets, :end_exp, :no_parse
+      attr_reader :regexp, :end_exp
+
+      def self.extended(by)
+        by.instance_exec do
+          @exps = {}
+        end
+      end
+
+      def initialize
+        @brackets ||= '[]'
+        @no_parse ||= '`'
+        @end_exp ||= '|'
+        exps = [  @brackets[0],
+                  @exps.keys.join,
+                  @end_exp,
+                  @no_parse,
+                  @brackets[1] ].map {|v| Regexp.escape(v) }
+
+        regexp = "%s([%s]+|%s+(%s)?)%s" % exps
+        @regexp = Regexp.new(regexp)
+        @initialized = true
+      end
+
+      def brackets(brackets=nil)
+        return  @brackets[0] + brackets + @brackets[1] if @brackets
+        @brackets ||= brackets
+      end
+
+      def end_exp(exp=nil)
+        @end_exp ||= exp
+      end
+
+      def method_missing(level, sym, args={})
+        exp(sym, level, args)
+      end
+
+      def exp(sym, state, args={})
+        sym = sym.to_s
+        @no_parse = sym if state == :noparse
+        @exps[sym] = Expression.new(sym, state, args)
+      end
+      
+      def parse(text)
+        initialize unless @initialized
+        Compiler.new(self, text).build
+      end
+    end
+
+    def self.included(by)
+      by.extend ClassMethods
+    end
+  end
+end

data/lib/bbsexp/expression.rb

@@ -0,0 +1,23 @@
+module BBSexp
+  class Expression
+    include Comparable
+    attr_reader :sym, :state, :tags, :block
+
+    def initialize(sym, state, args={})
+      @sym = sym
+      @state = case state
+               when :block   then 3
+               when :inline  then 2
+               when :func    then 1
+               when :noparse then 0
+               else state
+               end
+      @tags = args[:tags] || ['', '']
+      @block = args[:func]
+    end
+
+    def <=>(b)
+      @state <=> (b.class == Expression ? b.state : b.to_i)
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: bbsexp
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- tca
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-04 00:00:00.000000000 Z
+dependencies: []
+description: Concise BBcode Framework
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/bbsexp.rb
+- lib/bbsexp/expression.rb
+- lib/bbsexp/compiler.rb
+- lib/bbsexp/dialect.rb
+homepage: https://github.com/tca/bbsexp
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: Concise BBcode Framework
+test_files: []