herbgobbler 0.1.0

data/lib/core/i18n_key.rb

@@ -0,0 +1,74 @@
+class I18nKey
+
+  DEFAULT_KEY_NAME = "key"
+  
+  def initialize( text, key_store = [] )
+    @text = text
+    @key_store = key_store
+    @key_value = nil
+  end
+
+  def key_value
+    if( @key_value.nil? )
+      to_return = remove_html_tags( @text )
+      to_return = to_return.gsub( /[%{].*?[}]/, '' )
+      to_return = to_return.gsub( /[^a-zA-Z0-9]/, ' ' )
+      to_return = to_return.gsub( /[ ]+/, ' ' )
+      to_return = to_return.strip.downcase.chomp
+      to_return = to_return.gsub( / /, '_' )
+      to_return = cut_down_to_size( to_return )
+      to_return = ensure_no_duplicates( to_return )
+      self.key_value = to_return
+    end
+    @key_value
+  end
+
+  def key_value=(value)
+    @key_value = value
+    @key_store << value
+  end
+  
+  def to_s
+    key_value
+  end
+
+  private
+
+  def cut_down_to_size( string_to_remove )
+    if( string_to_remove.length < 15 )
+      string_to_remove
+    else
+      if( string_to_remove.rindex( '_' ) )
+        cut_down_to_size( string_to_remove[0..(string_to_remove.rindex('_')-1) ] )
+      else
+        string_to_remove
+      end
+    end
+  end
+
+  def exists_in_keystore?( value )
+    !(@key_store.index( value ).nil?)
+  end
+  
+  def ensure_no_duplicates( key_value, incrementor = 1 )
+    if( key_value.strip.empty? )
+      ensure_no_duplicates( DEFAULT_KEY_NAME )
+    elsif( exists_in_keystore?( key_value ) )
+      incremented_value = "#{key_value}_#{incrementor}"
+      if( exists_in_keystore?( incremented_value ) )
+        ensure_no_duplicates( key_value, incrementor + 1 )
+      else
+        incremented_value
+      end
+    else
+      key_value
+    end
+  end
+      
+  def remove_html_tags( string_to_remove )
+    string_to_remove.gsub( /<[\/]?[a-zA-Z]+[^<]*>/, '_')
+  end
+  
+  
+  
+end

data/lib/core/ignorable_tag_node.rb

@@ -0,0 +1,10 @@
+module IgnorableTagNode 
+  def text?
+    false
+  end
+
+  def top_level?
+    true
+  end  
+  
+end

data/lib/core/method_call_node.rb

@@ -0,0 +1,44 @@
+module MethodCallNode
+  include TextNode
+
+  def extract_text( text_extractor, node_tree, surrounding_nodes )
+    
+    text_string = ''
+    self.elements.each do |node|
+      if( node.is_a?( TextNode ) )
+        translated_node = text_extractor.translate_text( node.text_value )
+        text_string << "(#{translated_node.text_value})"
+      else
+        text_string << node.text_value
+      end   
+    end
+    
+    if( surrounded_by_text? (surrounding_nodes) )
+      text_extractor.add_variable( generate_i18n_key( text_extractor, node_tree ).to_s, text_string.strip )
+    else
+      node_tree << HerbNonTextNode.new( "<%= #{text_string.strip} %>" )
+    end
+    
+  end
+
+  private
+
+  def surrounded_by_text?( nodes )
+    # if the surrounding nodes only contain myself and <%= and %> then this
+    # is not surrounded by text
+    count_non_whitespace_nodes( nodes ) > 3 
+  end
+
+  def count_non_whitespace_nodes( nodes )
+    node_count = 0
+    
+    nodes.each do |node|
+      node_count += 1 unless node.text_value.strip.empty?
+    end
+
+    node_count
+  end
+  
+  
+  
+end

data/lib/core/node_processing.rb

@@ -0,0 +1,26 @@
+module NodeProcessing
+
+  
+  def flatten(node, leaves = [])
+    # This finds all of the leaves, where a leaf is defined as an
+    # element with no sub elements.  This also treats combindable nodes
+    # and text nodes as leaves because we want to keep them intact for
+    # extraction and combination
+    if( !node.respond_to?( :elements) ||
+        node.elements.nil? ||
+        node.elements.empty? ||
+        (node.is_a?( TextNode ) && !node.has_variables?)||
+        node.is_a?( HerbStringVariable ) || 
+        ( node.is_a?(NonTextNode) && node.can_be_combined? ) )
+      leaves << node if( !node.text_value.empty? )
+      leaves
+    else
+      node.elements.each do |sub_node|
+        flatten( sub_node, leaves )
+      end
+      leaves    
+    end
+  end
+
+  
+end

data/lib/core/non_extracting_non_text_node.rb

@@ -0,0 +1,8 @@
+module NonExtractingNonTextNode
+  include NonTextNode
+
+  def extract_text( text_extractor, node_tree )
+    # I do nothing!
+  end
+  
+end

data/lib/core/non_text_node.rb

@@ -0,0 +1,32 @@
+module NonTextNode
+  include BaseNode
+  def can_be_combined?
+    false
+  end
+
+  def extract_text( text_extractor, node_tree )
+    if( self.white_space? )
+      text_extractor.white_space( self )
+    else
+      text_extractor.add_non_text( self ) unless self.contains_only_whitespace?
+    end
+    
+  end
+
+  def contains_only_whitespace?
+    self.text_value.strip.length == 0
+  end
+  
+  def text?
+    false
+  end
+  
+  def top_level?
+    true
+  end  
+
+  def white_space?
+    false
+  end
+  
+end

data/lib/core/rails_text_extractor.rb

@@ -0,0 +1,88 @@
+class RailsTextExtractor < BaseTextExtractor
+  attr_reader :translation_store
+  
+  def initialize( translation_store = RailsTranslationStore.new )
+    @key_store = []
+    @translation_store = translation_store
+    @current_text = []
+    @current_nodes = []
+    @current_variables = []
+  end
+  
+  # This is called when text extraction has begun
+  def starting_text_extraction
+  end
+
+  def start_html_text
+    @current_text = []
+    @current_nodes = []
+    @current_variables = []
+  end
+
+  def end_html_text
+    whitespace, @current_text = strip_ending_whitespace_nodes( @current_text )
+
+    unless( @current_text.empty? && @current_variables.empty? )
+      total_text = @current_text.inject("") { |all_text, node| all_text + node.text_value }
+      @current_nodes << HerbErbTextCallNode.new( [total_text], @key_store, "t '.", "'", @current_variables )
+      @translation_store.add_translation( @current_nodes.last.key_value, @current_nodes.last.original_text )
+    end
+    
+    # Just reset everything here to be cautious
+    to_return = @current_nodes
+    @current_nodes = []
+    @current_text = []
+    
+    return to_return + whitespace
+  end
+
+  def white_space( node )
+    if( @current_text.empty? )
+      @current_nodes << node
+    else
+      @current_text << node
+    end
+  end
+
+  # This is used to add a new variable into the current html element
+  def add_variable( variable_name, variable_value)
+    variable_node = RailsTextVariableNode.new( variable_name, variable_value )
+    @current_text << variable_node
+    @current_variables << variable_node
+  end
+
+  # This is called to just produce a translated text node without erb
+  # braces around it.
+  def translate_text( text_to_translate )
+    call_node = HerbErbTextCallNode.new( [text_to_translate], @key_store, "t '.", "'", [], false )
+    @translation_store.add_translation( call_node.key_value, call_node.original_text )
+    call_node
+  end
+  
+  # This takes in a text node and returns one or more nodes that will
+  # then be output.  The nodes that are output should implement
+  # node_name and text_value
+  def add_html_text( text_node )
+    @current_text << text_node
+  end
+
+  
+  def add_non_text( non_text_node )
+    @current_text << non_text_node
+  end
+  
+  # This is called when text extraction has finished
+  def completed_text_extraction
+  end
+
+  protected
+
+  def strip_ending_whitespace_nodes( node_list )
+    whitespace = []
+    while( !node_list.empty? && node_list.last.white_space? )
+      whitespace << node_list.pop
+    end
+    return whitespace, node_list
+  end
+  
+end

data/lib/core/rails_translation_store.rb

@@ -0,0 +1,42 @@
+class RailsTranslationStore < BaseTranslationStore
+
+  def initialize( language = "en" )
+    super()
+    @language = language
+  end
+
+  # This goes out of it's way to keep things in exactly the correct
+  # order.  This makes it easier for translators when dealing with
+  # files.  This is the reason to not just throw things into a hash
+  # and serialize the hash
+  def serialize
+    to_return = "#{@language}:\n"
+    last_context = nil
+    self.each do |context, key, value|
+      whitespace_depth = 2
+      context_array = context.split('/')
+      context_array.each do |split_context|
+        to_return << "#{build_whitespace( whitespace_depth )}#{split_context}:\n" 
+        whitespace_depth += 2
+      end unless context == last_context
+        to_return << "#{build_whitespace( 2 + 2 * context_array.length )}#{key}: \"#{escape(value)}\"\n"
+      last_context = context
+    end
+    
+    to_return.chomp
+  end
+
+  private
+
+  def build_whitespace( amount )
+    " " * amount
+  end
+
+  private
+
+  
+  def escape( key )
+    key.gsub( /"/, '\"' ).gsub( "\n", "\\n" )
+  end
+  
+end

data/lib/core/text_extractor.rb

@@ -0,0 +1,31 @@
+# This is only meant to be a base class, please extend and implement
+# the base methods if you want to do anything interesting
+class TextExtractor
+
+  # This is called when text extraction has begun
+  def starting_text_extraction
+    raise "Please implement me (start_text_extraction)"
+  end
+
+  def add_html_text( text_node )
+    raise "Please implement me (add_html_text)"    
+  end
+
+  def add_variable( variable_name, variable_value )
+    raise "Please implement me (add_variable)"    
+  end
+
+  def translate_text( text_node_to_translate )
+    raise "Please impelement me (translate_text)"
+  end
+  
+  def end_html_text
+    raise "Please implement me (end_html_text)"
+  end
+
+  def start_html_text
+    raise "Please implement me (start_html_text)"
+  end
+
+   
+end

data/lib/core/text_node.rb

@@ -0,0 +1,73 @@
+module TextNode 
+  include BaseNode
+  include NodeProcessing
+
+  def extract_text( text_extractor, node_tree )
+    if( self.strip_whitespace? && self.has_leading_or_trailing_whitespace? )
+      self.remove_leading_and_trailing_whitespace.each do |node|
+        node.extract_text( text_extractor, node_tree )
+      end
+    else
+      text_extractor.add_html_text( self )
+    end
+  end
+
+  def has_variables?
+    false
+  end
+  
+  def html?
+    true
+  end
+
+  def strip_whitespace?
+    true
+  end
+  
+  def text?
+    true
+  end
+  
+  def top_level?
+    true
+  end  
+
+  def white_space?
+    false
+  end
+  
+
+  def amount_of_ending_whitespace
+    self.text_value.length - self.text_value.rstrip.length    
+  end
+  
+  def amount_of_starting_whitespace
+    self.text_value.length - self.text_value.lstrip.length    
+  end
+  
+  def has_leading_or_trailing_whitespace?
+    amount_of_ending_whitespace > 0 || amount_of_starting_whitespace > 0
+  end
+  
+  # This probably won't work, because I want it to retain all of the
+  # nodes.  Maybe we should run this after the text extraction
+  # happens?  Nope, that won't work....
+  def remove_leading_and_trailing_whitespace
+    to_return = []
+    if( self.text_value.strip.empty? ) # is this only whitespace
+      to_return << HerbWhiteSpaceTextNode.new( self.text_value )
+    else # otherwise it has some text
+      if( amount_of_starting_whitespace > 0 )
+        to_return << HerbWhiteSpaceTextNode.new( self.text_value[0..(amount_of_starting_whitespace - 1 )] )
+      end
+      to_return << HerbTextNode.new( self.text_value.strip )
+      if( amount_of_ending_whitespace > 0 )
+        to_return << HerbWhiteSpaceTextNode.new( self.text_value[(self.text_value.length - amount_of_ending_whitespace)..self.text_value.length ])
+      end
+    end
+
+    to_return
+  end
+  
+    
+end

data/lib/herbgobbler.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+$ERB_GRAMMER_FILE = File.expand_path( "#{File.expand_path( File.dirname( __FILE__) )}/../grammer/erb_grammer.treetop" )
+
+require 'rubygems'
+require 'treetop'
+require 'core/core'
+require 'nodes/nodes'

data/lib/nodes/combindable_herb_non_text_node.rb

@@ -0,0 +1,5 @@
+class CombindableHerbNonTextNode < HerbNonTextNode
+  def can_be_combined?
+    true
+  end
+end

data/lib/nodes/herb_combined_node.rb

@@ -0,0 +1,47 @@
+class HerbCombinedNode
+
+  def initialize( node_a, node_b )
+    @combined_nodes = [node_a, node_b]
+  end
+
+  def node_name
+    "herb_combined_nodes"
+  end
+
+  def can_be_combined?
+    true
+  end
+
+  def should_be_unrolled?
+    @combined_nodes.last.white_space?
+  end
+
+  def html?
+    true
+  end
+  
+  def text?
+    @combined_nodes.first.text? || @combined_nodes.last.text?
+  end
+  
+  def text_value
+    to_return = "";
+    @combined_nodes.each do |node|
+      to_return << node.text_value
+    end
+    to_return
+  end
+
+  def to_s
+    self.text_value
+  end
+
+  def whitespace?
+    @combined_nodes.first.whitespace? || @combined_nodes.last.whitespace?    
+  end
+  
+  def unroll
+    @combined_nodes
+  end
+  
+end

data/lib/nodes/herb_erb_text_call_node.rb

@@ -0,0 +1,52 @@
+class HerbErbTextCallNode
+
+  def initialize( text_values = [], key_store = [], prepend = nil, postpend = nil, variables = [], include_markup = true )
+    @text_values = text_values
+    @prepend = prepend
+    @postpend = postpend
+    @key_store = key_store
+    @key_value = nil
+    @include_markup = include_markup
+    @variables = variables
+  end
+
+  def add_text( text )
+    @text_values << text
+  end
+
+  def can_be_combined?
+    true
+  end
+  
+  def key_value
+    if( @key_value.nil? )
+      @key_value = I18nKey.new( original_text, @key_store ).key_value
+    end
+
+    @key_value
+  end
+
+  def node_name
+    "herb_erb_text_call_node"
+  end
+  
+  def original_text
+    @text_values.join( '' )
+  end
+  
+  def text_value
+    string_to_return = "#{@prepend}#{key_value}#{@postpend}"
+    string_to_return += ", #{@variables.join( ', ' )}" unless @variables.empty?
+    if( @include_markup )
+      "<%= #{string_to_return} %>"
+    else
+      string_to_return
+    end
+      
+  end
+  
+  def to_s
+    text_value
+  end
+  
+end

data/lib/nodes/herb_node_retaining_node.rb

@@ -0,0 +1,37 @@
+class HerbNodeRetainingNode
+
+  def initialize( first_node = nil )
+    @sub_nodes = []
+    @sub_nodes << first_node unless first_node.nil?
+  end
+  
+  def nodes
+    to_return = []
+    @sub_nodes.each do|node|
+      if( node.is_a?( HerbNodeRetainingNode ) )
+        to_return += node.nodes
+      else
+        to_return << node
+      end
+    end
+    to_return
+  end
+  
+  def <<(node)
+    if( node.is_a?(Array) )
+      @sub_nodes+= node
+    else
+      @sub_nodes << node
+    end
+    self
+  end
+  
+  def text_value
+    to_return = ""
+    @sub_nodes.each do |node|
+      to_return += node.text_value
+    end
+    to_return
+  end
+    
+end

data/lib/nodes/herb_node_retaining_non_text_node.rb

@@ -0,0 +1,30 @@
+class HerbNodeRetainingNonTextNode < HerbNodeRetainingNode
+  include NonTextNode
+
+  def initialize( first_node = nil )
+    super( first_node )
+    @can_be_combined = false
+  end
+
+  def <<(node)
+    super(node)
+    @can_be_combined ||= ( node.respond_to?( :can_be_combined? ) && node.can_be_combined? )
+  end
+
+  def can_be_combined?
+    @can_be_combined
+  end
+
+  def self.create_from_nodes( nodes )
+    to_return = HerbNodeRetainingNonTextNode.new
+    nodes.each do |node|
+      to_return << node
+    end
+    to_return
+  end
+  
+    
+  
+  
+  
+end