qipowl 0.9.0

data/lib/qipowl/bowlers/yaml.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require_relative '../core/bowler'
+
+module Qipowl
+  
+  # Markup processor for Yaml.
+  # 
+  # This class produces hash from YAML file.
+  class Yaml < Bowler
+    attr_reader :result
+    def initialize file = nil
+      super
+      merge_rules file if file
+    end
+    
+    def parse_and_roll str
+      @result = {}
+      @partial = nil
+      super str
+      @result
+    end
+    
+    # Tupla handler
+    def ： *args
+      from, till, *rest = args.flatten
+      if @partial.nil? or Hash === @partial
+        (@partial ||= {})[from.unuglify] = till.unuglify                   
+        rest
+      else
+        harvest :：, args.join(SEPARATOR).unbowl.unspacefy.uncarriage.strip
+      end
+    end
+    
+    # Array element handler
+    def － *args
+      (@partial ||= []) << args.join(SEPARATOR).unuglify
+      nil
+    end
+    
+    def harvest callee, str
+      if Hash === @partial 
+        if str == String::CARRIAGE_RETURN
+          key = @partial.keys.last
+          @partial.delete key
+          @result[key] = @partial
+        else
+          @result.merge! @partial
+        end
+      else
+        @result[str] = @partial unless str.vacant?
+      end
+      
+      @partial = nil
+    end
+    
+    def self.parse str
+      Yaml.new.parse_and_roll str
+    end
+    
+  end
+
+end

data/lib/qipowl/core/bowler.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+
+require_relative 'monkeypatches'
+require_relative '../utils/logging'
+
+# @author Alexei Matyushkin
+module Qipowl::Bowlers
+
+  # Base class for all the parsers.
+  #
+  # Technically it may be instantiated, but that’s meaningless.
+  # Main operation method for it and all the descendants is
+  # {#parse}. It sequentially executes following
+  # private methods:
+  #
+  # - {#defreeze}
+  # - {#roast}
+  # - {#serveup}
+  #
+  # Normally the developer does not need to interfere the {#roast}
+  # method which proceeds the input string. To prepare the input
+  # for +evaluation+ one overwrites {#defreeze}, for some afterwork
+  # the {#serveup} method is here.
+  #
+  # Descendants are supposed to overwrite {#method_missing} for some
+  # custom processing and introduce DSL methods, which will be executed
+  # by `eval` inside the {#roast} method.
+  #
+  # Instance variables `:in` and `:out` are here to gain an access to
+  # the last interpreted input string and the result of evaluation
+  # respectively.
+  #
+  class Bowler
+    include TypoLogging
+    
+    attr_reader :in, :out
+    
+    # Internal constant for joining/splitting the strings during processing.
+    # Override on your own risk. I can′t imagine why you would need to do so.
+    SEPARATOR = $, || ' '
+
+    def execute str
+      @out = (serveup roast defreeze @in = str)
+    end
+
+    # Everything is a DSL, remember?
+    #
+    # @return true
+    def respond_to?(method)
+      true
+    end
+
+    # Everything is a DSL, remember? Even constants.
+    # @todo This fails to do with DSLing words, beginning with capitals :-(
+    #
+    # @return the constant name as is
+    def self.const_missing name
+      raise "There was CONST [#{name}] met. Stupid programming error."
+      name
+    end
+
+    # If somebody needs to interfere the standard processing,
+    # she supposed to introduce `special_handler` method. The descendants
+    # will be processed before standard operation (which in fact simply
+    # collects words within an array one by one.)
+    def method_missing method, *args, &block
+      method, *args = special_handler(method, *args, &block) \
+        if self.private_methods.include?(:special_handler)
+      [method, args].flatten
+    end
+        
+    # Adds new +entity+ in the section specified.
+    # E. g., call to
+    #
+    #     add_spice :linewide, :°, :deg, :degrees
+    #
+    # in HTML implementation adds a support for specifying something like:
+    #
+    #     ° 15
+    #     ° 30
+    #     ° 45
+    #
+    # which is to be converted to the following:
+    #
+    #     <degrees>
+    #       <deg>15</deg>
+    #       <deg>30</deg>
+    #       <deg>45</deg>
+    #     </degrees>
+    #
+    # @param [Symbol] section the section (it must be one of {Mapping.SPICES}) to add new key to
+    # @param [Symbol] key the name for the key
+    # @param [Symbol] value the value
+    # @param [Symbol] enclosure_value optional value to be added for the key into enclosures section
+    def add_entity section, key, value, enclosure_value = null
+      if (tags = self.class.const_get("#{section.upcase}_TAGS"))
+        key = key.bowl.to_sym
+        tags[key] = value.to_sym
+        self.class.const_get("ENCLOSURES_TAGS")[key] = enclosure_value.to_sym if enclosure_value
+        self.class.class_eval %Q{
+          alias_method :#{key}, :∀_#{section}
+        } # unless self.class.instance_methods(true).include?(key.bowl)
+      else
+        logger.warn "Trying to add key “#{key}” in an invalid section “#{section}”. Ignoring…"
+      end
+    end
+
+    # Removes key from both {Mapping.SPICES} and {Mapping.SALT}. See {#add_spice}
+    #
+    # @param [Symbol] key the key to be removed
+    def remove_entity key
+      %w(block alone magnet grip regular).each { |section|
+        next unless send :"∃_#{section}_tag", key.to_sym
+        
+        self.class.const_get("#{section.upcase}_TAGS").delete key
+        self.class.const_get("ENCLOSURES_TAGS").delete key
+        self.class.class_eval %Q{
+          remove_method :#{key.bowl}
+        }
+      }
+    end
+
+
+  protected
+    %w(block alone magnet grip regular).each { |section|
+      define_method "∀_#{section}".to_sym, ->(*args) {
+        raise "Default method for #{section} (“#{self.class.name.gsub(/_\d+\Z/, '')}#∀_#{section}”) MUST be defined"
+      }
+    }
+
+    def defreeze str
+      str
+    end
+
+    def roast str
+      (split str).reverse.map { |dish|
+        @yielded = []
+        rest = begin
+          eval(dish.strip.carriage)
+        rescue Exception => e
+          msg = e.message.dup
+          logger.error '='*78
+          logger.error "Could not roast dish [#{msg.force_encoding(Encoding::UTF_8)}].\nWill return as is… Dish follows:"
+          logger.error '-'*78
+          logger.error dish
+          logger.error '='*78
+          [*dish]
+        end
+        harvest(nil, orphan([*rest].join(SEPARATOR))) # FIXME Check if this is correct in all the cases
+        @yielded.pop(@yielded.size).reverse.join(SEPARATOR)
+      }.reverse.join($/).uncarriage.un␚ify.unspacefy.unbowl
+    end
+  
+    def serveup str
+      str.gsub(/⌦./, '').gsub(/.⌫/, '')
+    end
+
+  protected
+    # The handler of the last “orphaned” text block in the input string.
+    #
+    # E.g.:
+    #     
+    #     Here goes a quite significant list:
+    #
+    #     • line item 1
+    #      • nested li1
+    #      • nested li 2
+    #     • line item 2
+    #
+    # While all line items are operated by `•` method, the top sentence
+    # is orphaned (has no prepnding DSL method to be called on.)
+    # Since we still need to handle it somehow, the {#orphan} method is here.
+    #
+    # @param [String] str the string to be operated “bu default rule”
+    # @return [String] the processed input (in derivatives, here it returns the untouched input string itself)
+    def orphan str
+      str
+    end
+
+    # The handler for harvesting partial result.
+    #
+    # Processing sometimes calls this method, designating the meaningful
+    # part of input text is done and should be yielded. E.g. when the
+    # block of code is processed:
+    #
+    #     Λ ruby
+    #       @mapping[:inplace].each { |tag, htmltag|
+    #         do_smth tag, htmltag
+    #       }
+    #     Λ
+    #
+    # After we have this part of input processed, it should be considered
+    # “done.” So block processors call {#harvest} to store processed parts.
+    #
+    # @param [Symbol] callee of this method. Qipowl hardly relies on method namings and sometimes we may need to know if the call was made by, say, lineitem DSL (`•`), not datalist (`▷`).
+    # @param [String] str string to yield
+    #
+    # @return nil
+    def harvest callee, str
+      @yielded << str unless str.vacant?
+      nil
+    end
+  
+  private
+    # Prepares blocks in the input for the execution
+    def block str
+      result = str.dup
+      self.class::BLOCK_TAGS.each { |tag, value|
+        result.gsub!(/(#{tag})\s*(\S*\s*|$)(.*?)(#{tag}|\Z)/m) {
+          %Q{
+
+#{$1}('#{$2.strip}', '#{$3.carriage}')
+
+}
+        }
+      }
+      result
+    end
+
+    # Prepares customs in the input for the execution
+    def custom str
+      result = str.unbowl.dup
+      self.class::CUSTOM_TAGS.each { |tag, value|
+        result.gsub!(/#{tag}/, value)
+      }
+      result.bowl
+    end
+
+    # Prepares grips in the input for the execution
+    # FIX<E There is a problem: we append a trailing space, need to remove it later!!
+    def grip str
+      result = str.dup
+      self.class::GRIP_TAGS.each { |tag, value|
+        result.gsub!(/(?:#{tag})(.*?)(?:#{tag})/m) {
+          next if (args = $1).vacant?
+          tag = value[:marker] if Hash === value && value[:marker]
+          "⌦ #{tag} #{args}#{tag}∎⌫"
+        }
+      }
+      result
+    end
+    
+    def split str
+      (block str.bowl).split(/\R{2,}/).map { |para|
+        para =~ /\A(#{self.class::BLOCK_TAGS.keys.join('|')})\(/ ?
+          para : (grip custom para)
+      }
+    end
+    
+  end
+end

data/lib/qipowl/core/mapper.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+require 'yaml'
+
+require_relative '../core/monkeypatches'
+require_relative '../utils/hash_recursive_merge'
+require_relative '../utils/logging'
+
+# @author Alexei Matyushkin
+module Qipowl::Mappers
+  
+  # Operates +mapping+ for loaded +YAML+ rules files.
+  #
+  # - For top level sections, each section name
+  #   should have the corresponding method within Mapping class;
+  #   default is `[:includes]` which is processed with {#includes}
+  #   method which is simply loads rules from the respective file
+  #
+  # Mapping may be loaded from YAML file, as well as be merged
+  # against other YAML file, hash or `Ruler` instance.
+  class Mapper
+    def initialize input = nil
+      @hash = {}
+      merge!(input) unless input.nil?
+    end
+    def to_hash
+      @hash
+    end
+    def merge! input
+      input = load_yaml(input) if input.is_one_of?(String, IO)
+      raise ArgumentError.new "Invalid map for merge in Mapper" \
+        unless input.respond_to? :to_hash        
+
+      incs = input.delete(:includes)
+
+      @entities_dirty = true
+      @hash.rmerge!(input.to_hash)
+      incs.each { |inc|
+        merge! inc
+      } rescue NoMethodError
+    end
+  private
+  # FIXME Make file search more flexible!!!
+    def load_yaml input
+      IO === input ?
+        YAML.load_stream(input) :
+        YAML.load_file("#{Qipowl.bowlers_dir}/#{input.downcase}.yaml")
+    end
+  end
+  
+  class BowlerMapper < Mapper
+    def initialize input = nil
+      input = self.class.name.split('::').last.downcase.gsub(/bowlermapper\Z/, '') if input.nil?
+      super input
+    end
+    @entities = nil
+    @entities_dirty = true
+
+    def entities
+      return @entities unless @entities_dirty
+      @entities = {}
+      @hash[:entities].each { |key, value| # :block. :alone etc
+        @entities[key] ||= {}
+        value.each { |k, v|
+          # Append keys
+          @entities[key][k.bowl] = v.dup
+          if Hash === v
+            @entities[key][k.bowl].delete(:synonyms) 
+            # Append explicit synonyms
+            v[:synonyms].each { |syn|
+              (@entities[key][syn.bowl] = v.dup).delete(:synonyms)
+              @entities[key][syn.bowl][:marker] = k.bowl
+            } if v[:synonyms]
+          end
+        }
+      }
+      @entities_dirty = false
+      @entities
+    end
+  end
+  
+  class HtmlBowlerMapper < BowlerMapper
+    
+  end
+end
+  
+if __FILE__ == $0
+  require '../../qipowl'
+  y = Qipowl::Mappers::BowlerMapper.new 'html'
+  require 'awesome_print'
+  ap y[:mail]
+end

data/lib/qipowl/core/monkeypatches.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+require_relative '../utils/hash_recursive_merge'
+
+module Qipowl
+  class ::Object
+    def is_one_of? *classes
+      !classes.each { |c| break false if c === self }
+    end
+  end
+  class ::Array
+    # Checks whether an array contains non-nil elements
+    # @return +true+ if an array does not contain non-nils and +false+ otherwise
+    def vacant?
+      (self.flatten - [nil]).empty?
+    end
+  end
+
+  # Bowling string means producing interpreter-safe text basing on ascii input.
+  # 
+  class ::String
+    NBSP = "\u{00A0}"
+    
+    SYMBOL_FOR_SPACE = "\u{2420}" # ␠
+    
+    WIDESPACE = "\u{FF00}"
+    EN_SPACE = "\u{2002}"
+    EM_SPACE = "\u{2003}"
+    THREE_PER_EM_SPACE = "\u{2004}"
+    FOUR_PER_EM_SPACE = "\u{2005}"
+    SIX_PER_EM_SPACE = "\u{2006}"
+    FIGURE_SPACE = "\u{2007}"
+    PUNCTUATION_SPACE = "\u{2008}"
+    THIN_SPACE = "\u{2009}"
+    HAIR_SPACE = "\u{200A}"
+    ZERO_WIDTH_SPACE = "\u{200B}"
+    NARROW_NO_BREAK_SPACE = "\u{202F}"
+    MEDIUM_MATHEMATICAL_SPACE = "\u{205F}"
+    ZERO_WIDTH_NO_BREAK_SPACE = "\u{FEFF}"
+    IDEOGRAPHIC_SPACE = "\u{3000}"    
+    
+    CARRIAGE_RETURN = '␍'
+    NULL = '␀'
+    ASCII_SYMBOLS, ASCII_DIGITS, ASCII_LETTERS_SMALL, ASCII_LETTERS_CAP = [
+        [(0x21..0x2F), (0x3A..0x40), (0x5B..0x60), (0x7B..0x7E)],
+        [(0x30..0x39)],
+        [(0x61..0x7A)],
+        [(0x41..0x5A)]
+    ].map { |current| current.map(&:to_a).flatten.map { |i| [i].pack('U') } }
+    ASCII_ALL = [ASCII_SYMBOLS, ASCII_DIGITS, ASCII_LETTERS_SMALL, ASCII_LETTERS_CAP]
+
+    CODEPOINT_ORIGIN = 0xFF00 - 0x0020 # For FULLWIDTH characters
+
+    UTF_SYMBOLS, UTF_DIGITS, UTF_LETTERS_SMALL, UTF_LETTERS_CAP = ASCII_ALL.map { |current|
+      Hash[* current.join.each_codepoint.map { |char|
+        [[char].pack("U"), [char + CODEPOINT_ORIGIN].pack("U")]
+      }.flatten]
+    }
+    UTF_ALL = [UTF_SYMBOLS.values, UTF_DIGITS.values, UTF_LETTERS_SMALL.values, UTF_LETTERS_CAP.values]
+    
+    UTF_ASCII = UTF_SYMBOLS.merge(UTF_DIGITS).merge(UTF_LETTERS_SMALL).merge(UTF_LETTERS_CAP)
+    ASCII_UTF = UTF_ASCII.invert
+    
+    def vacant?
+      nil? || empty?
+    end
+    
+    def hsub! hash
+      self.gsub!(/#{hash.keys.join('|')}/, hash)
+    end
+    def hsub hash
+      (out = self.dup).hsub! hash
+      out
+    end
+    def bowl!
+      self.gsub!(/[#{Regexp.quote(ASCII_ALL.join)}]/, UTF_ASCII)
+    end
+    def bowl
+      (out = self.dup).bowl!
+      out
+    end
+    def unbowl!
+      self.gsub!(/[#{Regexp.quote(UTF_ALL.join)}]/, ASCII_UTF)
+    end
+    def unbowl
+      (out = self.dup).unbowl!
+      out
+    end
+    def spacefy!
+      self.gsub!(' ', SYMBOL_FOR_SPACE)
+    end
+    def spacefy
+      (out = self.dup).spacefy!
+      out
+    end
+    def unspacefy!
+      self.gsub!(/#{SYMBOL_FOR_SPACE}/, ' ')
+    end
+    def unspacefy
+      (out = self.dup).unspacefy!
+      out
+    end
+    
+    def unuglify
+      self.unbowl.unspacefy.uncarriage.strip
+    end
+
+    HTML_ENTITIES = Hash[[['<', 'lt'], ['>', 'gt'], ['&', 'amp']].map { |k, v| [k.bowl, "&#{v};"] }]
+
+    def carriage
+      self.gsub(/\R/, " #{CARRIAGE_RETURN} ")
+    end
+    def carriage!
+      self.gsub!(/\R/, " #{CARRIAGE_RETURN} ")
+    end
+    def uncarriage
+      self.gsub(/ #{CARRIAGE_RETURN} /, %Q(
+))
+    end
+    def uncarriage!
+      self.gsub!(/ #{CARRIAGE_RETURN} /, %Q(
+))
+    end
+
+    def un␚ify
+      self.gsub(/␚(.*?)␚/, '')
+    end
+    
+    def wstrip
+      self.gsub(/#{NBSP}/, '')
+    end
+    
+    def to_filename
+      self.gsub(/[#{Regexp.quote(ASCII_SYMBOLS.join)}]/, UTF_ASCII).gsub(/\s/, "#{NBSP}")[0..50]
+    end
+  end
+  
+  class ::Symbol
+    def dup
+      self.to_s.dup.to_sym
+    end
+    def bowl
+      self.to_s.bowl.to_sym
+    end
+    def unbowl
+      self.to_s.unbowl.to_sym
+    end
+    def spacefy
+      self.to_s.spacefy.to_sym
+    end
+    def unspacefy
+      self.to_s.unspacefy.to_sym
+    end
+    def unuglify
+      self.to_s.unuglify.to_sym
+    end
+    def wstrip
+      self.to_s.wstrip.to_sym
+    end
+  end
+  
+  class ::Fixnum
+    def ␚ify
+      "␚#{self}␚"
+    end
+  end
+  
+end

data/lib/qipowl/core/ruler.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require_relative '../utils/logging'
+
+# @author Alexei Matyushkin
+module Qipowl
+  
+  # Operates +mapping+ for loaded +YAML+ rules files.
+  #
+  # - For top level sections, each section name
+  #   should have the corresponding method within Mapping class;
+  #   default is `[:includes]` which is processed with {#includes}
+  #   method which is simply loads rules from the respective file
+  #
+  # Mapping may be loaded from YAML file, as well as be merged
+  # against other YAML file, hash or `Ruler` instance.  
+  module Ruler
+    include TypoLogging
+    extend self
+
+    @@bowlers = {} # FIXME REDIS!!!!
+    @@yamls = {}
+
+    
+    def get_bowler id: nil, type: nil
+      @@bowlers[id] || new_bowler(type, true)
+    end
+  
+    def new_bowler type, persistent = false
+      yaml, clazz = \
+        case type
+        when Class
+          ["#{type.to_s.split('::').last.downcase}", type]
+        when String, Symbol
+          ["#{type.to_s.downcase}", Qipowl::Bowlers.const_get(type.to_s.capitalize.to_sym)]
+        end
+      
+      raise NameError.new("Invalid bowler type: #{type}") \
+        unless clazz.is_a?(Class) && clazz < Qipowl::Bowlers::Bowler
+      
+      id = "#{Time.now.to_i}#{rand(1..1_000_000_000)}"
+      name = "#{clazz.name.split('::').last}_#{id}"
+      clazz = Qipowl::Bowlers.const_set(name, Class.new(clazz))
+
+      teach_class clazz, get_yaml(yaml)
+
+      persistent ? [@@bowlers[id] = clazz.new, id] : clazz.new
+    end
+      
+  private
+    def get_yaml yaml
+      return @@yamls[yaml] if @@yamls[yaml]
+      
+      clazz = Qipowl::Mappers.const_get("#{yaml.capitalize}BowlerMapper")
+      raise NameError.new("Invalid mapper type: #{clazz}") \
+        unless clazz.is_a?(Class) && clazz < Qipowl::Mappers::BowlerMapper
+        
+      @@yamls[yaml] = clazz.new
+    end
+    def teach_class clazz, mapper
+      clazz.const_set("CUSTOM_TAGS", mapper.to_hash[:custom])
+      clazz.const_set("ENCLOSURES_TAGS", mapper.to_hash[:enclosures])
+      clazz.const_set("TAGS", {})
+      clazz.class_eval %Q{
+        def ∃_enclosures entity
+          self.class::ENCLOSURES_TAGS.each { |k, v|
+            next unless k == entity
+            v = {:tag => v} unless Hash === v
+            v[:origin] = self.class::TAGS[v[:tag]]
+            return v
+          }
+          nil
+        end
+      }
+      %w(block alone magnet grip regular).each { |section|
+        clazz.const_set("#{section.upcase}_TAGS", mapper.entities[section.to_sym])
+        clazz.class_eval %Q{
+          #{clazz}::TAGS.rmerge! #{clazz}::#{section.upcase}_TAGS
+          def ∃_#{section} entity
+            self.class::#{section.upcase}_TAGS.each { |k, v|
+              next unless k == entity
+              v = {:tag => v} unless Hash === v
+              v[:section] = k
+              return v
+            }
+            nil
+          end
+          def ∃_#{section}_tag entity
+                ∃_#{section}(entity)[:tag] if ∃_#{section}(entity)
+          end
+        }
+        mapper.entities[section.to_sym].each { |key, value|
+          tag = Hash === value && value[:marker] ? value[:marker] : "∀_#{section}"
+          clazz.class_eval %Q{
+            alias_method :#{key}, :#{tag}
+          } unless clazz.instance_methods.include?(key)
+        }
+      }
+      clazz.class_eval %Q{
+        def ∀_tags
+          self.class::TAGS.keys
+        end
+      }
+    end
+  end
+end