phrase_assembler 0.0.9

data/lib/PAProxies/PAAssembleProxy.rb

@@ -0,0 +1,110 @@
+require './lib/PAProxies/PALinkProxy'
+class PAAssembleProxy < PALinkProxy
+  attr_accessor :max_tokens_level
+
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger, self.grammar, false, false, self.max_tokens_level)
+  end
+
+  def method_missing(sym, *args, &block)
+    if args[0].is_a? Integer
+      proxy = super(sym, *args, &block)
+      proxy = proxy[args[0]]
+      args.delete_at(0)
+    elsif args[0]== :r
+      proxy = super(sym, *args, &block)
+      proxy = proxy[rand(proxy.data_length)]
+      args.delete_at(0)
+    else
+      proxy = super(sym, *args, &block)
+    end
+
+    if ((args[0].is_a? String) and (!args[0].empty?))
+      tokens = args[0].split(':', 2)
+      if tokens.length >= 1
+        args[0] = tokens[1]
+      else
+        args.delete_at(0)
+      end
+
+      if tokens[0].index(/\[(\d+|r)\]/).nil?
+        proxy = proxy.send(tokens[0].to_sym, *args, &block)
+      else
+        token_name = tokens[0][/[^\[]+/]
+        token_index = tokens[0][/\[(\d+|r)\]/][1...-1]
+        if token_index == "r"
+          token_index = :r
+        else
+          token_index = token_index.to_i
+        end
+        args.insert(0, token_index)
+        proxy = proxy.send(token_name.to_sym, *args, &block)
+      end
+    end
+    proxy
+  end
+
+  def data=(p_data)
+    @data = p_data
+    change_data(@data)
+  end
+
+  def change_data(p_data)
+    @data_changed = true
+    data_changing_iteration = 0
+    while(@data_changed)
+      @data_changed = false
+      change_sequence_tokens(p_data, p_data)
+      data_changing_iteration = data_changing_iteration + 1
+      raise "Tokens stack level too deep, max is: #{max_tokens_level}" if data_changing_iteration > max_tokens_level
+    end
+  end
+
+  def initialize(p_data = {}, logger = nil, grammar = {}, init_grammar = true, init_data = true, p_max_tokens_level = 5)
+    self.max_tokens_level = p_max_tokens_level
+    if init_data
+      change_data(p_data)
+    end
+    super(p_data, logger, grammar, init_grammar)
+  end
+
+  def change_sequence_tokens(p_data, root_data)
+    if p_data.is_a? Hash
+      p_data.each_key{|k| change_sequence_tokens(p_data[k], root_data)}
+    elsif p_data.is_a? Array
+      p_data.each_index{|index| change_sequence_tokens(p_data[index], root_data)}
+    elsif p_data.is_a? String
+      return change_sequence_token(p_data, root_data)
+    end
+  end
+
+  def change_sequence_token(p_data, root_data)
+    #TODO srediti da je regex takav da ne mora imati * u [^\{\}\*] dijelu
+    #p_data.gsub!(/\{\*[^(\{\*)(\*\})](:[^(\{\*)(\*\})])+\*\}/){|token|
+    p_data.gsub!(/\{\*@[^\{\}\*\?]+(:[^\{\}\*]+)*\*\}/){|tokens_seq|
+      tokens = tokens_seq[3...-2].split(':')
+      temp_proxy = PAProxy.new(root_data, self.logger)
+      for i in 0..tokens.length-1
+        if tokens[i].index(/\[(\d+|r)\]/).nil?
+          temp_proxy = temp_proxy.create_new_proxy(tokens[i].to_sym)
+          @data_changed = true
+        else
+          token_name = tokens[i][/[^\[]+/]
+          token_index = tokens[i][/\[(\d+|r)\]/][1...-1]
+          temp_proxy = temp_proxy.create_new_proxy(token_name.to_sym)
+          if token_index != "r"
+            token_index = token_index.to_i
+          else
+            token_index = rand(temp_proxy.data.length)
+          end
+          temp_proxy = temp_proxy[token_index]
+          @data_changed = true
+        end
+      end
+      unless temp_proxy.data.is_a? String
+        raise 'Not assembled to end'
+      end
+      temp_proxy.data.to_s
+    }
+  end
+end

data/lib/PAProxies/PACacheProxy.rb

@@ -0,0 +1,27 @@
+module PACacheProxy
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+  end
+
+  module ClassMethods
+    def self.extended(base)
+      class << base
+        alias_method :new_without_cache, :new unless method_defined?(:new_without_cache)
+        alias_method :new, :new_with_cache
+      end
+    end
+
+    def new_with_cache(*args)
+      t_cache_id = self.cache_id(*args)
+      unless (t_cache_id.nil?) or (self.proxy_cache[t_cache_id].nil?)
+        self.proxy_cache[t_cache_id].set_uncacheable_args(*args)
+        object = self.proxy_cache[t_cache_id]
+      else
+        object = self.new_without_cache(*args)
+        self.proxy_cache[t_cache_id] = object unless t_cache_id.nil?
+      end
+      object
+    end
+  end
+
+end

data/lib/PAProxies/PACompositeProxy.rb

@@ -0,0 +1,32 @@
+require './lib/PAProxies/PAAssembleProxy'
+require './lib/PAProxies/PAStringProxy'
+require './lib/PAProxies/PACacheProxy'
+class PACompositeProxy < PAAssembleProxy
+  include PAStringProxy
+  include PACacheProxy
+  
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger, self.grammar, false, false, self.max_tokens_level)
+  end
+  
+  @@proxy_cache = {}
+  def self.proxy_cache
+    @@proxy_cache
+  end
+  
+  def set_uncacheable_args(p_data = {}, p_logger = nil, p_grammar = {}, init_grammar = true, init_data = true, max_tokens_level = 5)
+  end
+  
+  def get_default_options
+    
+  end
+  
+  def self.cache_id(p_data = {}, logger = nil, options = {}, grammar = {}, init_grammar = true, init_data = true, max_tokens_level = 5)
+    if p_data.nil?
+      return nil
+    else
+      return "PAID_#{p_data.object_id.to_s}"
+    end
+  end
+  
+end

data/lib/PAProxies/PALangProxy.rb

@@ -0,0 +1,86 @@
+require './lib/PAProxies/PATokenProxy'
+class PALangProxy < PATokenProxy
+  attr_accessor :grammar
+  
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger, self.grammar, false)
+  end
+  
+  def initialize(data = {}, logger = nil, grammar = {}, init_grammar = true)
+    if init_grammar
+      set_grammar(grammar)
+    else
+      @grammar = grammar
+    end
+    super(data, logger)
+  end
+  
+  def set_grammar(grammar)
+    @grammar = HashAddOn.symbolize_keys_recursive_for_hash(grammar, true)
+    @grammar.each{|k, v|
+      if (v.is_a? Hash and (!v.has_key? :default))
+        @grammar[k][:default] = v.values.sort{|a, b| a <=> b}.join('/')
+      end
+    }
+  end
+  
+  def load_grammar(file_name)
+    set_grammar(YAML::load(File.read(file_name)))
+    self
+  end
+  
+  def get_grammar_token(key, g_value, values)
+    if @grammar[key].nil?
+      raise 'Grammar key not existing'
+    elsif !@grammar[key][g_value].nil?
+      return values[@grammar[key][g_value].to_i]
+    else
+      return @grammar[key][:default].gsub(/\d+/){|index|
+        values[index.to_i]
+      } 
+    end
+  end
+  
+  def substitute_token(p_data, add_options = {}, p_options = {})
+    #TODO srediti da je regex takav da ne mora imati * u [^\{\}\*] dijelu
+    #p_data.gsub(/\{\*[^(\{\*)(\*\})\?]+\?[^(\{\*)(\*\}):]+(:[^(\{\*)(\*\}):]+)+\*\}/){|token|
+    p_data.gsub!(/\{\*[^\{\}\*\?]+\?[^\{\}\*:]+(:[^\{\}\*:]+)+\*\}/){|token|
+      clear_token = token[2...-2]
+      key = clear_token[/[^\?]+/]
+      opt_params = key[/\(.+\)/]
+      unless opt_params.nil?
+        opt_params = opt_params[1...-1].split(',').collect{|v| 
+          raise 'No param' if p_options.options_hash[v.strip.to_sym].nil?
+          p_options.options_hash[v.strip.to_sym]
+        }
+      end
+      key = key[/[^(\(.+\))]+/]
+      keys = key.split('_')
+      if keys.length <= 1
+        options_key = "default"
+        grammar_key = keys[0]
+      else
+        options_key = keys[0]
+        grammar_key = keys[1]
+      end
+      
+      values = clear_token[/\?.+/][1..-1].split(':')
+      if p_options.options_hash.has_key?(options_key.to_sym)
+        if opt_params.nil?
+          grammar_value = p_options.options_hash[options_key.to_sym].send(:"get_#{grammar_key}")
+        else
+          grammar_value = p_options.options_hash[options_key.to_sym].send(:"get_#{grammar_key}", opt_params)
+        end
+      elsif p_options.options_hash.has_key?("#{options_key}_#{grammar_key}".to_sym)
+        grammar_value = p_options.options_hash["#{options_key}_#{grammar_key}".to_sym]
+      end
+      if grammar_value.nil?
+        raise 'No token for lang'
+      end
+      add_options["!#{clear_token}"] = get_grammar_token(grammar_key.to_sym, grammar_value.to_sym, values)
+      "{*!#{clear_token}*}"
+    }
+    return super(p_data, add_options, p_options)
+  end
+end
+

data/lib/PAProxies/PALinkProxy.rb

@@ -0,0 +1,37 @@
+require './lib/PAProxies/PALangProxy'
+class PALinkProxy < PALangProxy
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger, self.grammar, false)
+  end
+  
+  def substitute_token(p_data, add_options = {}, p_options = {})
+    #TODO srediti da je regex takav da ne mora imati * u [^\{\}\*] dijelu
+    #@data.gsub!(/\{\*[^(\{\*)(\*\})]+->[^(\{\*)(\*\})]+\*\}/){|link_token|
+    p_data.gsub!(/\{\*[^\{\*\})]+->[^\{\*\})]+\*\}/){|link_token|
+      link_data = link_token.split("->")
+      link_text = link_data[0][2..-1]
+      link_url = link_data[1][0...-2]
+      
+      unless(link_text.index(/'[^'"]+'/).nil? and link_text.index(/"[^'"]+"/).nil?) 
+        link_text = "#{link_text[1...-1]}"
+      else
+        link_text = "{*#{link_text}*}"
+      end
+      
+      if p_options.options_hash[link_url.to_sym].is_a? Hash
+        identifier = "!link_url_#{link_url.object_id}"
+        add_options[identifier] = p_options.options_hash[link_url.to_sym][:href]
+        add_attributes = ""
+        p_options.options_hash[link_url.to_sym].keys.sort{|a,b| a.to_s <=> b.to_s}.collect{|k| 
+          add_attributes += " #{k} = '#{p_options.options_hash[link_url.to_sym][k]}'" if k != :href
+        }
+        result = "<a href = '{*#{identifier}*}'#{add_attributes}>#{link_text}</a>"
+      else
+        result = "<a href = '{*#{link_url}*}'>#{link_text}</a>"
+      end
+      
+      result
+    }
+    return super(p_data, add_options, p_options)
+  end
+end

data/lib/PAProxies/PAProxy.rb

@@ -0,0 +1,20 @@
+require './lib/PAProxies/PAProxyData'
+class PAProxy < PAProxyData
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger)
+  end
+  
+  def method_missing(sym, *args, &block)
+    create_new_proxy(sym)
+  end
+  
+  def create_new_proxy(sym)
+    if @data.has_key?(sym)
+      return new_instance(@data[sym])
+    elsif @data.has_key?(sym.to_s)
+      return new_instance(@data[sym.to_s])
+    else
+      raise "Could not assemble: "
+    end
+  end
+end

data/lib/PAProxies/PAProxyData.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+class PAProxyData
+  attr_accessor :data
+  attr_accessor :logger
+  
+  def initialize(p_data = {}, p_logger = nil)
+    self.data = p_data
+    self.logger = p_logger
+    self
+  end
+  
+  def data_length
+    @data.length
+  end
+  
+  def load(file_name)
+    self.data = HashAddOn.symbolize_keys_recursive_for_hash(YAML::load(File.read(file_name)), true)
+    self
+  end
+  
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger)
+  end
+  
+  def [](index)
+    if @data.is_a? Array
+      if index == :r
+        return new_instance(@data[rand(@data.length)])
+      elsif index < @data.length
+        return new_instance(@data[index])
+      else
+        raise 'out of bonds'
+      end
+    else
+      raise 'Non array'
+    end
+  end
+ 
+end

data/lib/PAProxies/PAStringProxy.rb

@@ -0,0 +1,12 @@
+module PAStringProxy
+  def to_s(p_options = nil)
+    temp_data = get_data(p_options)
+    if temp_data.is_a? Array
+      raise "Can not put Array to String"
+    elsif temp_data.is_a? Hash
+      raise "Can not put Hash to String"
+    else
+      return temp_data.to_s
+    end
+  end
+end

data/lib/PAProxies/PATokenProxy.rb

@@ -0,0 +1,97 @@
+require './lib/PAProxies/PAProxy'
+class PATokenProxyOptions
+  attr_accessor :options_hash
+  attr_accessor :indices_hash
+  
+  def self.new_if_needed(p_options)
+    if (p_options.is_a? PATokenProxyOptions)
+      return p_options
+    else  
+      return self.new(p_options)
+    end
+  end
+  
+  def reset
+    calculate_indices(options_hash) if !@added_indices
+    @added_indices = true
+  end
+  
+  def initialize(p_options)
+    self.options_hash = p_options
+    self.indices_hash = {}
+    reset
+  end
+
+  def get_current_index(array)
+    return indices_hash[array.object_id.to_s]
+  end
+  
+  def inc_index(array)
+    indices_hash[array.object_id.to_s] = indices_hash[array.object_id.to_s] + 1
+    if indices_hash[array.object_id.to_s] >= array.length
+      indices_hash[array.object_id.to_s]= 0
+    end
+  end
+
+  private
+  def calculate_indices(hash)
+    if hash.is_a? Array
+      indices_hash[hash.object_id.to_s] = 0
+      hash.each{|hash_element| calculate_indices(hash_element)}
+    elsif hash.is_a? Hash
+      hash.each_value{|val| calculate_indices(val)}
+    end
+  end
+end
+
+class PATokenProxy < PAProxy
+  def new_instance(p_data)
+    return self.class.new(p_data, self.logger)
+  end
+  
+  def get_data(p_options = {})
+    substitute_tokens(self.data, PATokenProxyOptions.new_if_needed(p_options))
+  end
+
+  def substitute_tokens(p_data, p_options)
+    if p_data.is_a? Hash
+      return substitute_hash(p_data, p_options)
+    elsif p_data.is_a? Array
+      return p_data.collect{|v| substitute_tokens(v, p_options)}
+    elsif p_data.is_a? String
+      return substitute_token(String.new(p_data), {}, p_options)
+    end
+  end
+  
+  def substitute_hash(p_data, p_options)
+    t_hash = {}
+    p_data.keys.sort{|a, b| a.to_s <=> b.to_s}.each{|k| t_hash[k] = substitute_tokens(p_data[k], p_options)}
+    return t_hash
+  end
+  
+  def substitute_token(p_data, add_options = {}, p_options = {})
+    #TODO srediti da je regex takav da ne mora imati * u [^\{\}\*] dijelu
+    #return_p_data = p_data.gsub(/\{\*[^(\{\*)(\*\})]+\*\}/){|token|
+    return_p_data = p_data.gsub(/\{\*[^\{\}\*]+\*\}/){|token|
+        sym_token = token[2...-2]
+        if sym_token[0...1]!="!"
+          sym_token = sym_token.to_sym
+        end
+        
+        add_options.merge!(p_options.options_hash)
+        
+        if add_options[sym_token].nil?
+          raise 'No token value'
+        elsif add_options[sym_token].is_a? Array
+          result = add_options[sym_token][p_options.get_current_index(add_options[sym_token])]
+          p_options.inc_index(add_options[sym_token])
+        else
+          result = add_options[sym_token]
+        end
+        
+        result
+      }
+     return_p_data 
+  end
+
+end

data/lib/hash_add_on.rb

@@ -0,0 +1,33 @@
+module HashAddOn
+  def self.symbolize_keys_recursive_for_hash(hash, downcase)
+    if hash.is_a? Hash
+      sym_hash = {}
+      
+      hash.each{|key, value| 
+        if (downcase)
+          if (key.is_a? String)
+            down_key = key.downcase
+          else 
+            down_key = key.to_s.downcase
+          end
+        else
+          down_key = key
+        end
+        sym_hash[down_key.to_sym] = value
+      }
+      
+      sym_hash.keys.each{|key|
+        if (sym_hash[key].is_a? Hash or sym_hash[key].is_a? Array)
+          sym_hash[key] = self.symbolize_keys_recursive_for_hash(sym_hash[key], downcase)
+        end
+        }
+      return sym_hash  
+    elsif hash.is_a? Array
+      hash = hash.collect{|val| self.symbolize_keys_recursive_for_hash(val, downcase)}
+      return hash
+    else
+      return hash
+    end
+    
+  end
+end

data/lib/phrase_assembler.rb

@@ -0,0 +1,97 @@
+require './lib/PAProxies/PACompositeProxy'
+module PhraseAssembler
+  def supress_errors
+    @@supress_errors
+  end
+  
+  def supress_errors=(value)
+    @@supress_errors = value
+  end
+  
+  def self.included(base)
+    base.send :extend, InitMethods
+    base.instance_eval do
+      def self._fields
+        self.send(:class_variable_get, :@@_fields)
+      end
+      
+      def self._fields=(value)
+        self.send(:class_variable_set, :@@_fields, value)
+      end
+      
+      def self._default_pref_language
+        self.send(:class_variable_get, :@@_default_pref_language)
+      end
+      
+      def self._default_pref_language=(value)
+        self.send(:class_variable_set, :@@_default_pref_language, value)
+      end
+      
+      def self._languages
+        self.send(:class_variable_get, :@@_languages)
+      end
+      
+      def self._languages=(value)
+        self.send(:class_variable_set, :@@_languages, value)
+      end
+      
+      def self._grammars
+        self.send(:class_variable_get, :@@_grammars)
+      end
+      
+      def self._grammars=(value)
+        self.send(:class_variable_set, :@@_grammars, value)
+      end
+      
+      def self._languages_files_path
+        self.send(:class_variable_get, :@@_languages_files_path)
+      end
+      
+      def self._languages_files_path=(value)
+        self.send(:class_variable_set, :@@_languages_files_path, value)
+      end
+        
+      def self._logger
+        self.send(:class_variable_get, :@@_logger)
+      end
+      
+      def self._logger=(value)
+        self.send(:class_variable_set, :@@_logger, value)
+      end
+    end
+  end
+
+  module InitMethods
+    
+    def acts_as_phrase_assembler(options = {})
+      self._fields = (options[:fields] || {:sex => :sex, :pref_language => :pref_language} )
+      self._default_pref_language = (options[:default_pref_language] || 'hr')
+      self._languages = (options[:languages] || {'hr' => 'croatian.yml', 'rs' => 'serbian.yml', 'si' => 'slovenian.yml'})
+      self._grammars = (options[:grammars] || {'hr' => 'croatian_grammar.yml', 'rs' => 'serbian_grammar.yml', 'si' => 'slovenian_grammar.yml'})
+      self._languages_files_path = (options[:languages_files_path] || File.join(RAILS_ROOT, 'app', 'yaml', 'languages'))
+      self._logger = (options[:logger] || RAILS_DEFAULT_LOGGER)
+      
+      send :include, InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    attr_reader :phrase
+    
+    @@proxies = {}
+    def phrase
+      t_pref_language = self.send(self.class._fields[:pref_language])
+      t_pref_language = self.class._default_pref_language if (t_pref_language.nil? or t_pref_language.empty?)
+      if @@proxies[t_pref_language].nil?
+        @@proxies[t_pref_language] = PACompositeProxy.new(nil, self.class._logger)
+        @@proxies[t_pref_language].load(File.join(self.class._languages_files_path, self.class._languages[t_pref_language]) )
+        @@proxies[t_pref_language].load_grammar(File.join(self.class._languages_files_path, self.class._grammars[t_pref_language]))
+      end
+      @@proxies[t_pref_language]
+    end
+    
+    def get_sex
+      self.send(self.class._fields[:sex])
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: phrase_assembler
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 9
+  version: 0.0.9
+platform: ruby
+authors: 
+- "Lovro \xC5\xBDmak, Radan Skori\xC4\x87, Drap"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-09 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Gem for building phrases from yml
+email: lovro.zmak@drap.hr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/hash_add_on.rb
+- lib/PAProxies/PAAssembleProxy.rb
+- lib/PAProxies/PACacheProxy.rb
+- lib/PAProxies/PACompositeProxy.rb
+- lib/PAProxies/PALangProxy.rb
+- lib/PAProxies/PALinkProxy.rb
+- lib/PAProxies/PAProxy.rb
+- lib/PAProxies/PAProxyData.rb
+- lib/PAProxies/PAStringProxy.rb
+- lib/PAProxies/PATokenProxy.rb
+- lib/phrase_assembler.rb
+has_rdoc: true
+homepage: http://www.drap.hr
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: nowarning
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Gem for building phrases
+test_files: []
+