qipowl 0.9.3 → 0.9.7

data/lib/qipowl/bowlers/i_sp_ru.rb

@@ -1,10 +1,10 @@
 # encoding: utf-8
 
 # КТО ЧТО_ДЕЛАЕТ КОМУ   ЧТО
-#  ☺       ⚙         ♿      ☕
+#  ☺       ⚙     ♿     ☕
 
 # КАКОЙ   КАК   КАКОЙ  КАКОЙ
-#  ☼        ☂        ☼       ☼
+#  ☼      ☂     ☼      ☼
 
 # ПОКА НЕ ОПРЕДЕЛЕНА ЧАСТЬ РЕЧИ (найти термин для)
 #                 ∈
@@ -19,7 +19,7 @@ require_relative '../core/bowler'
 module Qipowl
   module Mappers
     class IspruBowlerMapper < BowlerMapper
-      
+
     end
   end
 
@@ -30,7 +30,7 @@ module Qipowl
 
       LANG_FROM = 'es' # FIXME UGLY
       LANG_TO   = 'ru' # FIXME UGLY
-      
+
 ##############################################################################
 ###              Default handlers for all the types of markup              ###
 ##############################################################################
@@ -73,20 +73,20 @@ module Qipowl
       # @see {Qipowl::Bowler#serveup}
       #
       # Additionally it beatifies the output HTML
-      # 
+      #
       # @param [String] str to be roasted
       def serveup str
-        (super str).typo(LANG_TO).strip
+        (super str).typo(lang: LANG_TO).strip
       end
 
     private
-      # Hence we cannot simply declare the DSL for it, we need to handle 
+      # Hence we cannot simply declare the DSL for it, we need to handle
       # calls to all the _methods_, starting with those symbols.
-      # 
+      #
       # @param [Symbol] method as specified by caller (`method_missing`.)
       # @param [Array] args as specified by caller (`method_missing`.)
       # @param [Proc] block as specified by caller (`method_missing`.)
-      # 
+      #
       # @return [Array] the array of words
       def special_handler method, *args, &block
         ∀_word method, args, block

data/lib/qipowl/constants.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
 module Qipowl
+  BTRACE_COUNT = 6
   ENTITIES = %w(block alone magnet grip regular self)
-end
+end

data/lib/qipowl/core/bowler.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'typogrowth'
+
 require_relative "../constants"
 require_relative '../utils/logging'
 
@@ -34,9 +36,9 @@ module Qipowl::Bowlers
   #
   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 = $, || ' '
@@ -99,9 +101,11 @@ module Qipowl::Bowlers
         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.const_get("ENTITIES")[section.to_sym][key] = value.to_sym
         self.class.class_eval %Q{
           alias_method :#{key}, :∀_#{section}
         } # unless self.class.instance_methods(true).include?(key.bowl)
+        @shadows = nil
       else
         logger.warn "Trying to add key “#{key}” in an invalid section “#{section}”. Ignoring…"
       end
@@ -109,21 +113,25 @@ module Qipowl::Bowlers
 
     # Removes key from both {Mapping.SPICES} and {Mapping.SALT}. See {#add_spice}
     #
-    # @param [Symbol] key the key to be removed
-    def remove_entity key
+    # @param [Symbol] entity the key to be removed
+    def remove_entity entity
+      key = entity.to_sym
       Qipowl::ENTITIES.each { |section|
         next unless (curr_sect = self.class.const_get("#{section.upcase}_TAGS") rescue nil)
-        next unless send :"∃_#{section}_tag", key.to_sym
-        
+        curr_tag = send(:"∃_#{section}", key)
+        next unless curr_tag
+
         curr_sect.delete key
         self.class.const_get("ENCLOSURES_TAGS").delete key
+        self.class.const_get("ENTITIES")[section.to_sym].delete key
+
         self.class.class_eval %Q{
           remove_method :#{key.bowl}
         }
+        @shadows = nil
       }
     end
 
-
   protected
     Qipowl::ENTITIES.each { |section|
       define_method "∀_#{section}".to_sym, ->(*args) {
@@ -132,7 +140,7 @@ module Qipowl::Bowlers
     }
 
     def defreeze str
-      str
+      str.typo(sections: :quotes).defuse
     end
 
     def roast str
@@ -143,7 +151,10 @@ module Qipowl::Bowlers
         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:\n\n"
+          logger.error "Could not roast dish [#{msg.force_encoding(Encoding::UTF_8)}].\nWill return as is… Backtrace:\n"
+          logger.error e.backtrace.take(Qipowl::BTRACE_COUNT).join("\n")
+          logger.error '-'*78
+          logger.error "Dish follows:\n"
           logger.error '-'*78
           logger.error dish
           logger.error '='*78
@@ -153,16 +164,16 @@ module Qipowl::Bowlers
         @yielded.pop(@yielded.size).reverse.join(SEPARATOR)
       }.join($/).uncarriage.un␚ify.unspacefy.unbowl
     end
-  
+
     def serveup str
-      str.gsub(/⌦./, '').gsub(/.⌫/, '')
+      str.gsub(/⌦./, '').gsub(/.⌫/, '').typo
     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
@@ -195,25 +206,25 @@ module Qipowl::Bowlers
     # 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 [Symbol] cally 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
+    def harvest cally, str
       @yielded << str unless str.vacant?
       nil
     end
-  
+
   private
     # Prepares blocks in the input for the execution
     def block str
       return str unless self.class.const_defined?(:BLOCK_TAGS)
       result = str.dup
       self.class::BLOCK_TAGS.each { |tag, value|
-        result.gsub!(/(#{tag})\s*(\S*\s?|$)(.*?)(#{tag}|\Z)/m) {
+        result.gsub!(/(#{tag})(.*?)(?:#{tag}|\Z)/m) { |m|
           %Q{
 
-#{$1} #{$2.strip.bowl} #{$3.bowl.carriage}
+#{$1} #{Base64.encode64($2).carriage(false).bowl}
 
 }
         }
@@ -245,14 +256,12 @@ module Qipowl::Bowlers
       }
       result.unbowl
     end
-    
+
     def split str
       (block str).split(/\R{2,}/).map { |para|
-        self.class.const_defined?(:BLOCK_TAGS) &&
-              (para =~ /\A(#{self.class::BLOCK_TAGS.keys.join('|')})\s+/) ?
-          para : (grip custom para)
+        (grip custom para)
       }
     end
-    
+
   end
 end

data/lib/qipowl/core/mapper.rb

@@ -8,7 +8,7 @@ require_relative '../utils/logging'
 
 # @author Alexei Matyushkin
 module Qipowl::Mappers
-  
+
   # Operates +mapping+ for loaded +YAML+ rules files.
   #
   # - For top level sections, each section name
@@ -27,30 +27,34 @@ module Qipowl::Mappers
       @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        
+      map = load_yaml(input) if input.is_one_of?(String, IO)
+      raise ArgumentError.new "Invalid map (#{input} @ #{Qipowl.bowlers}) for merge in Mapper.\nCurrent dir: [#{Dir.pwd}].\n" \
+        unless map.respond_to? :to_hash
 
-      incs = input.delete(:includes)
+      incs = map.delete(:includes)
 
       @entities_dirty = true
-      @hash.rmerge!(input.to_hash)
+      @hash.rmerge!(map.to_hash)
       incs.each { |inc|
         merge! inc
       } rescue NoMethodError # FIXME WTF rescueing here?
     end
   private
-  # FIXME Make file search more flexible!!!
+    def load_yaml_file name
+      [*Qipowl.bowlers].each { |b|
+        (return YAML.load_file("#{b}/#{name}.yaml")) rescue next
+      }
+      nil
+    end
+
     def load_yaml input
-      IO === input ?
-        YAML.load_stream(input) :
-        YAML.load_file("#{Qipowl.bowlers_dir}/#{input.downcase}.yaml")
+      IO === input ? YAML.load_stream(input) : load_yaml_file("#{input.downcase}")
     end
   end
-  
+
   class BowlerMapper < Mapper
     include TypoLogging
-    
+
     def initialize input = nil
       input = self.class.name.split('::').last.downcase.gsub(/bowlermapper\Z/, '') if input.nil?
       super input
@@ -67,11 +71,12 @@ module Qipowl::Mappers
           # Append keys
           @entities[key][k.bowl] = v.dup
           if Hash === v
-            @entities[key][k.bowl].delete(:synonyms) 
+            @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
+              syn = syn.bowl.to_sym
+              (@entities[key][syn] = v.dup).delete(:synonyms)
+              @entities[key][syn][:marker] = k.bowl
             } if v[:synonyms]
           end
         }
@@ -81,10 +86,3 @@ module Qipowl::Mappers
     end
   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

@@ -18,12 +18,12 @@ module Qipowl
   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}"
@@ -38,8 +38,8 @@ module Qipowl
     NARROW_NO_BREAK_SPACE = "\u{202F}"
     MEDIUM_MATHEMATICAL_SPACE = "\u{205F}"
     ZERO_WIDTH_NO_BREAK_SPACE = "\u{FEFF}"
-    IDEOGRAPHIC_SPACE = "\u{3000}"    
-    
+    IDEOGRAPHIC_SPACE = "\u{3000}"
+
     CARRIAGE_RETURN = '␍'
     NULL = '␀'
     ASCII_SYMBOLS, ASCII_DIGITS, ASCII_LETTERS_SMALL, ASCII_LETTERS_CAP = [
@@ -58,14 +58,14 @@ module Qipowl
       }.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
@@ -101,41 +101,34 @@ module Qipowl
       (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} ")
+    def carriage spaces = true
+      self.gsub(/\R/, spaces ? " #{CARRIAGE_RETURN} " : "#{CARRIAGE_RETURN}")
     end
-    def uncarriage
-      self.gsub(/\s?#{CARRIAGE_RETURN}\s?/, %Q(
-))
-    end
-    def uncarriage!
-      self.gsub!(/\s?#{CARRIAGE_RETURN}\s?/, %Q(
+    def uncarriage spaces = true
+      self.gsub(spaces ? /\s?#{CARRIAGE_RETURN}\s?/ : /#{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
@@ -159,11 +152,11 @@ module Qipowl
       self.to_s.wstrip.to_sym
     end
   end
-  
+
   class ::Fixnum
     def ␚ify
       "␚#{self}␚"
     end
   end
-  
+
 end

data/lib/qipowl/core/ruler.rb

@@ -5,7 +5,7 @@ require_relative '../utils/logging'
 
 # @author Alexei Matyushkin
 module Qipowl
-  
+
   # Operates +mapping+ for loaded +YAML+ rules files.
   #
   # - For top level sections, each section name
@@ -14,18 +14,18 @@ module Qipowl
   #   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.  
+  # against other YAML file, hash or `Ruler` instance.
   module Ruler
     include TypoLogging
     extend self
 
     @@bowlers = {} # FIXME REDIS!!!!
-    
+
     def get_bowler id: nil, type: nil
       @@bowlers[id] || new_bowler(type, true)
     end
-  
-    def new_bowler type, persistent = false
+
+    def new_bowler type, persistent: false, additional_maps: []
       yaml, clazz = \
         case type
         when Class
@@ -33,63 +33,73 @@ module Qipowl
         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)
+      teach_class clazz, get_yaml(yaml, additional_maps: additional_maps)
 
       persistent ? [@@bowlers[id] = clazz.new, id] : clazz.new
     end
-      
+
   private
-    def get_yaml yaml
+    def get_yaml yaml, additional_maps: []
       clazz = Qipowl::Mappers.const_get("#{yaml.capitalize}BowlerMapper")
       raise NameError.new("Invalid mapper type: #{clazz}") \
         unless clazz.is_a?(Class) && clazz < Qipowl::Mappers::BowlerMapper
-        
-      clazz.new
+
+      result = clazz.new
+      [*additional_maps].each { |map|
+        result.merge! map
+      }
+      result
     end
-        
-    # FIXME Make contants PER-EIGENCLASS
-    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("ENTITIES", mapper.entities)
-      clazz.const_set("TAGS", {})
-      clazz.class_eval %Q{
-        def ∃_enclosures entity
-          self.class::ENCLOSURES_TAGS.each { |k, v|
+
+    def teach_class_prepare clazz
+      clazz.const_set('CUSTOM_TAGS', {}) unless clazz.const_defined? 'CUSTOM_TAGS'
+      clazz.const_set('ENCLOSURES_TAGS', {}) unless clazz.const_defined? 'ENCLOSURES_TAGS'
+      Qipowl::ENTITIES.each { |section|
+        clazz.const_set("#{section.upcase}_TAGS", {}) \
+          unless clazz.const_defined? "#{section.upcase}_TAGS"
+      }
+      clazz.const_set('ENTITIES', {}) unless clazz.const_defined? 'ENTITIES'
+      clazz.const_set('TAGS', {}) unless clazz.const_defined? 'TAGS'
+    end
+
+    def ∃_template section
+      %Q{
+        def ∃_#{section} entity
+          self.class::#{section.upcase}_TAGS.each { |k, v|
             next unless k == entity
             v = {:tag => v} unless Hash === v
             v[:origin] = self.class::TAGS[v[:tag]]
+            v[:section] = k
             return v
           }
           nil
         end
       }
+    end
+
+    def teach_class clazz, mapper
+      teach_class_prepare clazz
+
+      clazz::CUSTOM_TAGS.rmerge! mapper.to_hash[:custom] if mapper.to_hash[:custom]
+      clazz::ENCLOSURES_TAGS.rmerge! mapper.to_hash[:enclosures] if mapper.to_hash[:enclosures]
+      clazz::ENTITIES.rmerge! mapper.entities if mapper.entities
+
+      clazz.class_eval ∃_template 'enclosures'
+
       Qipowl::ENTITIES.each { |section|
         next unless mapper.entities && mapper.entities[section.to_sym]
-        clazz.const_set("#{section.upcase}_TAGS", mapper.entities[section.to_sym])
-        clazz.class_eval %Q{
-          self::TAGS.rmerge! self::#{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
-        }
+        clazz.const_get("#{section.upcase}_TAGS").rmerge! mapper.entities[section.to_sym]
+        clazz.const_get('TAGS').rmerge! clazz.const_get("#{section.upcase}_TAGS")
+        clazz.class_eval ∃_template section
+
         mapper.entities[section.to_sym].each { |key, value|
           tag = Hash === value && value[:marker] ? value[:marker] : "∀_#{section}"
           clazz.class_eval %Q{
@@ -97,11 +107,6 @@ module Qipowl
           } unless clazz.instance_methods.include?(key.to_sym)
         }
       }
-      clazz.class_eval %Q{
-        def ∀_tags
-          self.class::TAGS.keys
-        end
-      }
     end
   end
 end