pretty_text 0.1

data/README

@@ -0,0 +1,9 @@
+PrettyText
+============
+
+Put your TTF fonts in the fonts/ directory.
+Use the pretty_text helper to include rendered texts in your views:
+
+<%= pretty_text "here goes the text", {:font => 'gill.ttf',
+                                       :size => 12,
+                                       :color => '#f00'} %>

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the text_renderer plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the text_renderer plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TextRenderer'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/pretty_text.rb

@@ -0,0 +1,126 @@
+module Cabird # :nodoc:
+  # This class represents a rendered text. It provides methods to get the path and
+  # the geometry to the generated image.
+  # Some parameters of the rendering process can be set using the global Hash
+  # <tt>PRETTY_TEXT</tt>. These are the configuration keys for <tt>PRETTY_TEXT</tt>:
+  # [<tt>:image_path</tt>]
+  #   The public path where the plugin stores the rendered images relative to the
+  #   public path. Defaults to 'images/pretty_text'
+  # [<tt>:scale_threshold</tt>]
+  #   Some fonts might look a little bit ugly at smaller sizes. <tt>PrettyText</tt>
+  #   tries to fix that by rendering small fonts 5 times bigger and scaling the
+  #   result down to the original size. You can set a threshold for the font size
+  #   in pts. All fonts smaller than this threshold will be rendered using this
+  #   scale hack.
+  # [<tt>:scale_filter</tt>]
+  #   The ImageMagick filter which is used for resizing. Defaults to
+  #   <tt>Magick::GaussianFilter</tt>.
+  # [<tt>:scale_support</tt>]
+  #   The support argument used by the ImageMagick <tt>resize</tt> method. Defaults
+  #   to 0.5.
+  class  PrettyText
+    require 'RMagick'
+    require 'fileutils'
+
+    @@config = Hash.new
+    mattr_writer :config
+    SCALE_FACTOR = 5
+
+    attr_reader :content
+
+    # This class method is used to set up a new <tt>PrettyText</tt> object. If the requested
+    # image is not yet created, it generates the image and returns the approprate
+    # <tt>PrettyText</tt> object.
+    def self.create(text, style = nil)
+      text = text.to_s
+      if (style.class.to_s != "Cabird::PrettyTextStyle")
+        style = Cabird::PrettyTextStyle.new(style)
+      end
+
+      # set up paths
+      public_image_path = @@config[:image_path] || File.join('system' , 'pretty_text')
+      public_path = File.join(public_image_path, style.generate_filename(text))
+      absolute_path = File.join(RAILS_ROOT, 'public', public_path)
+
+      # render small fonts bigger and scale down later
+      size = style.size
+      scale_hack = size <= (@@config[:scale_threshold] || 12)
+      size *= SCALE_FACTOR if scale_hack
+      
+      if (!File.exist?(absolute_path))
+        # create directory
+        FileUtils.mkpath(File.dirname(absolute_path)) unless File.exists?(File.dirname(absolute_path))
+
+        gc = Magick::Draw.new
+        gc.font = File.join(RAILS_ROOT, 'fonts', style.font) if style.font
+        gc.pointsize = size
+        #gc.kerning(style.kerning)
+        gc.gravity = Magick::NorthWestGravity
+        gc.fill = style.color
+        text_to_render = style.process_text(text)
+        gc.text(style.xoffset, style.yoffset, text_to_render)
+
+        metrics = gc.get_multiline_type_metrics(text_to_render)
+        image = Magick::Image.new(metrics.width + style.xextra + style.xoffset, metrics.height + style.yextra + style.yoffset) do
+          self.background_color = style.bg_color
+        end
+        gc.draw(image)
+
+        # scale down to original size
+        if scale_hack
+          image.resize!(metrics.width / SCALE_FACTOR,
+                        metrics.height / SCALE_FACTOR,
+                        @@config[:scale_filter]  || Magick::GaussianFilter,
+                        @@config[:scale_support] || 0.5)
+        end
+        # handle gif transparency
+        if (style.format == :gif)
+          image = image.matte_replace(0, 0)
+        end
+
+        image.write(absolute_path)
+      end
+
+      return self.new(text, public_path)
+    end
+
+    # The constructor is used by the <tt>create</tt> factory method. You should not use it,
+    # but use the <tt>create</tt> method instead.
+    def initialize(text, public_path)
+      @content = text
+      @public_path = public_path
+    end
+
+    # Returns the relative path of the image starting at the public directory
+    def path
+      return File.join('', @public_path)
+    end
+
+    # Return the width of the image
+    def width
+      get_geometry if @width.nil?
+      return @width
+    end
+      
+    # Returns the height of the image
+    def height
+      get_geometry if @height.nil?
+      return @height
+    end
+
+    # Returns the string the image is created from
+    def to_s
+      return @text
+    end
+
+    private
+
+    # Retrieves the geometry of the image and saves it to the <tt>@width</tt> and
+    # <tt>@height</tt> attributes of the class
+    def get_geometry
+      image = Magick::Image.read(File.join(RAILS_ROOT, 'public', @public_path)).first
+      @width = image.columns
+      @height = image.rows
+    end
+  end
+end

data/lib/pretty_text_helper.rb

@@ -0,0 +1,57 @@
+module Cabird # :nodoc:
+  # This module contains helper methods to create <tt>PrettyText</tt> objects and to include
+  # the generated image in your view.
+  module PrettyTextHelper
+    # This helper creates a <tt>PrettyText</tt> object and shows the generated text as
+    # background image of a HTML-tag.
+    # You can set the style of the rendered text by a <tt>PrettyTextStyle</tt> object
+    # or by a hash:
+    #
+    #   <% @style = Cabird::PrettyTextStyle.new(:color => '#666666', :size => 30) %>
+    #   <%= pretty_text("the text", @style, 'h1')
+    #
+    # or
+    #
+    #   <%= pretty_text("the text", {:color => '#666666', :size => 30}, 'h1')
+    #
+    # which will result in the same output:
+    #
+    #   <h1 style="... background: url('...'); ...">the text</h1>
+    #
+    # Using the <tt>PrettyTextStyle</tt> class gives you the opportunity to use a kind of
+    # style inheritance:
+    #
+    #   <% @style = Cabird::PrettyTextStyle.new(:color => '#666666', :size => 30) %>
+    #   <%= pretty_text("a headline", @style, 'h1')
+    #   <%= pretty_text("normal text", @style.alter(:size => 12), 'p')
+    #
+    # Use the html_options to append HTML options to the tag:
+    #   <%= pretty_text("the text", @style, 'h1', {:class => "myclass"})
+    def pretty_text(str, style = nil, tag="span", html_options = nil)
+      text = Cabird::PrettyText.create(str, style);
+
+      if html_options
+        html_options = html_options.stringify_keys
+        convert_options_to_javascript!(html_options)
+        tag_options = tag_options(html_options)
+      else
+        tag_options = nil
+      end
+
+      style  = "display:block;overflow:hidden;text-indent:-9999px;"
+      style << "width:#{text.width}px;height:#{text.height}px; "
+      style << "background:left top no-repeat url('#{image_path(text.path)}');"
+
+      ret =  "<#{tag} style=\"#{style}\"#{tag_options}>"
+      ret << h(text.content)
+      ret << "</#{tag}>"
+    end
+
+    # This method returns the public path to the rendered text. The parameters are the same
+    # as the two first parameters of the pretty_text method.
+    def pretty_text_path(str, style = nil)
+      text = Cabird::PrettyText.create(str, style);
+      return text.path
+    end
+  end
+end

data/lib/pretty_text_style.rb

@@ -0,0 +1,113 @@
+module Cabird # :nodoc:
+  # This class represents a style used by the <tt>PrettyText</tt> class to generate
+  # an image. This style includes font properties like the font-file and the font-size,
+  # colors and text transformation like upcase.
+  #
+  # Possible style attributes are:
+  # [<tt>format</tt>]
+  #   Can either be <tt>:png</tt> or <tt>:gif</tt>, defaults to <tt>:png</tt>.
+  #   If <tt>:gif</tt> is used set the <tt>bg_color</tt> attribute to get proper
+  #   antialiasing.
+  # [<tt>color</tt>]
+  #   The color of the rendered text. Use HTML/CSS style color definitions (eg.:
+  #   ##fff, ##d2d2d2). Defaults to ##fff.
+  # [<tt>bg_color</tt>]
+  #   If you choose <tt>:gif</tt> as format the text will be rendered against the given
+  #   <tt>bg_color</tt> and the areas of the background which are not effected by the
+  #   antialiasing are cut out. This way you get proper antialiasing, although the gif
+  #   format does not support alpha channels.
+  # [<tt>size</tt>]
+  #   The size of the rendered font in points
+  # [<tt>font</tt>]
+  #   The font file to use relative to the font root directory, which is fonts by default
+  # [<tt>upcase</tt>]
+  #   This flag defines if the text is transformed to uppercase before rendering.
+  #   This boolean defaults to false.
+  # [<tt>extra_width</tt>]
+  #   Sometimes Imagemagick will calculate the wrong width for the image. You can add
+  #   some extra space by setting this value. Defaults to 0. This might be obsolete due
+  #   to an former error in the implementation.
+  #
+  # You can set the atrributes via the constructor:
+  #   style = Cabird::PrettyTextStyle.new({:format => :png, :color => '#f00'})
+  # or via the setter methods:
+  #   style.color = '#000'
+  class PrettyTextStyle
+    #require 'RMagick'
+
+#    require 'digest/md5'
+    require 'unicode'
+    
+    @@default = {:format => :png,
+                 :color => '#000',
+                 :bg_color => '#fff',
+                 :size => 12,
+                 :font => nil,
+                 :upcase => false,
+                 :extra_width => 0,
+                 :xextra => 0,
+                 :xoffset => 0,
+                 :yextra => 0,
+                 :yoffset => 0,
+                 :kerning => 0}
+
+    # define getters and setters with default
+    @@default.keys.each do |key|
+      # getter method
+      define_method key do
+        return @attributes[key] || @@default[key]
+      end
+
+      # setter method
+      define_method key.to_s + '=' do |value|
+        @attributes[key] = value
+      end
+    end
+
+    # Sets up a new <tt>PrettyTextStyle</tt> object. All of the above mentioned attributes
+    # can be set here.
+    def initialize(attributes = nil)
+      @attributes = attributes || Hash.new
+    end
+
+    # This method overrides the default getter method for the <tt>bg_color</tt> method.
+    def bg_color
+      return "transparent" if self.format == :png
+      return @attributes[:bg_color] || @@default[:bg_color]
+    end
+
+    # Applies all text transformations to a given text, which includes only the
+    # <tt>upcase</tt> option at the moment. Returns the transformed text.
+    def process_text(text)
+      return (self.upcase == true) ? Unicode::upcase(text) : text
+    end
+
+    # Generates a hash string of all attributes and a given string. This method is used
+    # by the <tt>generate_filename</tt> method to retrieve the filename for a combilnation
+    # of style attributes and a certain text.
+    def generate_hash(str = "")
+       to_hash = str
+       @@default.keys.each do |key|
+         to_hash += self.send(key).to_s
+       end
+       return  Digest::MD5.hexdigest(to_hash)
+    end
+
+    # This method generates a hashed filename of the style attributes and a given text
+    def generate_filename(str)
+      fragments = self.generate_hash(str).scan(/(..)/).flatten
+      return File.join(fragments) + "." + self.format.to_s
+    end
+
+    # Clones this <tt>PrettyTextStyle</tt> object and returns an altered version of the clone.
+    # You can override attributes with the argument.
+    def alter(attributes = Hash.new)
+      result = Hash.new
+      @@default.keys.each do |key|
+        result[key] = (attributes[key]) ? attributes[key] :
+                                          @attributes[key]
+      end
+      return self.class.new(result)
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,10 @@
+# Include hook code here
+require 'pretty_text'
+require 'pretty_text_style'
+require 'pretty_text_helper'
+
+# load configuration
+Cabird::PrettyText.config = PRETTY_TEXT if Object.const_defined?(:PRETTY_TEXT)
+
+# include helpers
+ActionView::Base.send(:include, Cabird::PrettyTextHelper)

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: pretty_text
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Claas Abert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-08 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- lib/pretty_text.rb
+- lib/pretty_text_helper.rb
+- lib/pretty_text_style.rb
+- rails/init.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A TTF font rendering plugin for rails using RMagick.
+test_files: []
+