flurin-buttonize 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Flurin Egger, DigitPaint (http://www.digitpaint.nl)
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,39 @@
+Buttonize, your favourite button generator.
+===========================================
+
+Buttonize is a little tool to generate sets of buttons by creating simple image templates (a left side, a repeatable middle
+and a right side). You can use buttonize do create sets of buttons and sets of button styles. See the examples directory
+for more information (examples/buttons.rb is a buttonset file and examples/default/styles.rb is a styleset file)
+
+
+Installing
+============
+
+Buttonize has the following dependencies:
+
+* Ruby 1.8.x (not tested in 1.9.x)
+* Rubygems
+* RMagick
+* Thor (for the commandline tool)
+
+If all is well you can just install the gem by running:
+
+sudo gem install flurin-buttonize --source=http://gems.github.com
+
+
+Quickstart
+==========
+
+For the impatient who just want to generate a blue button (and have all required stuff installed)!
+
+Run: 
+buttonize button --style=big_blue "My first button"
+
+and open
+my_first_button.gif
+
+
+Copyright & license
+===================
+
+Copyright (c) 2009 Flurin Egger, DigitPaint, MIT Style License. (see MIT-LICENSE)

data/bin/buttonize

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + "/../lib/buttonize"
+require File.dirname(__FILE__) + "/../lib/buttonize/cli"
+
+Buttonize::CLI.start

data/examples/buttons.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + "/../lib/buttonize"
+
+buttons = Buttonize::ButtonSet.define(:style_file => File.dirname(__FILE__) + "/default/styles.rb", :style_set => :default) do |set|
+  
+  set.button "Test", :style => :small_green
+  
+  set.group("big",:style => :big_green) do |s|
+    s.button "Confirm"
+    s.button "Export", "export"
+    s.button "Import", "import", :width => 65
+  end
+
+  set.group("big",:style => :big_blue) do |s|
+    s.button "Continue"
+  end
+
+  set.group("small", :style => :small_red) do |s|
+    s.button "Unsubscribe"
+  end
+end
+
+# This will not be ran if you use the buttonize commandline script
+buttons.generate(:target_path => "~/temp/button_out")

data/examples/default/styles.rb

@@ -0,0 +1,23 @@
+Buttonize::StyleSet.define(:template_path => File.dirname(__FILE__)) do |set|
+  set.style(:big_blue) do |s|
+    s.font_size = 10
+    s.template_base = "big_blue"
+    s.paddings = [20,20]
+  end
+
+  set.style(:big_orange, :based_on => :big_blue, :template_base => "big_orange")
+  set.style(:big_red, :based_on => :big_blue, :template_base => "big_red")
+  set.style(:big_green, :based_on => :big_blue, :template_base => "big_green")
+
+  set.style(:small_blue, :font_size => 9, :template_base => "small_blue", :width => 65)
+  set.style(:small_orange, :based_on => :small_blue, :template_base => "small_orange")
+  set.style(:small_red, :based_on => :small_blue, :template_base => "small_red")
+  set.style(:small_green, :based_on => :small_blue, :template_base => "small_green")
+end
+ 
+# Styles = {   
+#   :table_blue => {:fontsize => 8, :base => "table_blue", :paddings => [5,5], :font => File.dirname(__FILE__) + "/fonts/slkscrb.ttf", :antialias => false},
+#   :table_orange => {:fontsize => 8, :base => "table_orange", :paddings => [5,5], :font => File.dirname(__FILE__) + "/fonts/slkscrb.ttf", :antialias => false},
+#   :table_red => {:fontsize => 8, :base => "table_red", :paddings => [5,5], :font => File.dirname(__FILE__) + "/fonts/slkscrb.ttf", :antialias => false},
+#   :table_green => {:fontsize => 8, :base => "table_green", :paddings => [5,5], :font => File.dirname(__FILE__) + "/fonts/slkscrb.ttf", :antialias => false}
+# }

data/lib/buttonize.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rmagick'
+include Magick
+require 'fileutils'
+include FileUtils
+
+module Buttonize
+  def run_in_cli!
+    @run_in_cli = true
+  end
+  
+  def cli?
+    @run_in_cli
+  end
+  
+  module_function :run_in_cli!, :cli?
+end
+
+require File.dirname(__FILE__) + "/buttonize/button"
+require File.dirname(__FILE__) + "/buttonize/style_set"
+require File.dirname(__FILE__) + "/buttonize/button_set"
+

data/lib/buttonize/button.rb

@@ -0,0 +1,90 @@
+class Buttonize::Button
+  
+  attr_reader :options
+  
+  def initialize(options)
+    @options = {
+      :font_size => 9, 
+      :paddings => [10,10], 
+      :width => nil, 
+      :template_base => "button",
+      :template_path => File.dirname(__FILE__) + "/../../examples/default",        
+      :font => "Arial",#File.dirname(__FILE__) + "/fonts/verdanab.ttf", 
+      :text_offset => {:x => 0, :y => 0},
+      :target_path => Dir.pwd,
+      :antialias => true
+    }.update(options)
+    @options[:template_images] ||=  ["_left","_middle","_right"].map{|p| options[:template_base] + p + ".gif" }
+    
+    # Validation
+    @options[:template_images].each{|i| raise "Missing template_image #{i}" unless File.exist?(File.join(options[:template_path],i)) }
+  end
+  
+  def log(text)
+    puts text
+  end
+  
+  def generate(text, filename = nil)
+    filename ||= self.text_to_filename(text)
+    filename = add_extension(filename,"gif")
+    paddings = options[:paddings]
+
+    # Load the images
+    left,mid,right = options[:template_images].map{|p| Image.read(File.join(options[:template_path],p)).first }  
+
+    draw = Draw.new
+    draw.pointsize = options[:font_size]
+    draw.fill = "#fff"
+    draw.gravity = Magick::CenterGravity
+    draw.font = options[:font]
+    draw.font_weight = Magick::BoldWeight
+    draw.text_antialias = options[:antialias] || false
+    
+    # Measure the text first
+    metrics = draw.get_type_metrics(text)
+    target_width = metrics.width + paddings[0] + paddings[1]
+
+    target_width = options[:width] if options[:width] && options[:width] > target_width
+
+    self.log "Generating image with text \"#{text}\" and width #{target_width}px and height #{left.rows}px"
+    dst = Image.new(target_width,left.rows) { self.background_color = "transparent"}
+
+    # Place left
+    dst.composite!(left,0,0,Magick::OverCompositeOp)
+
+    # Fill up the middle
+    pos = left.columns
+    while pos < (target_width - right.columns) do
+      if pos + mid.columns >= (target_width - right.columns)
+        leftover = target_width - pos - right.columns
+        dst.composite!(mid,(pos - (mid.columns - leftover)),0,Magick::OverCompositeOp)
+        pos = pos - (mid.columns - leftover) +  mid.columns
+      else
+        dst.composite!(mid,pos,0,Magick::OverCompositeOp)
+        pos += mid.columns  
+      end
+
+    end
+
+    # Place right
+    dst.composite!(right,pos,0,Magick::OverCompositeOp)
+    draw.annotate(dst,0,0,options[:text_offset][:x],options[:text_offset][:y],text)
+    dst.write(File.join(options[:target_path],filename))
+    dst.destroy!
+    
+    filename      
+  end
+
+  def text_to_filename(text)
+    text.to_s.downcase.gsub(/[^a-z0-9]/,"_").squeeze("_").gsub(/_$/,"") 
+  end
+  
+  def add_extension(filename,extension)
+    if filename =~ /\.#{extension}$/
+      filename
+    else
+      filename + "." + extension
+    end
+  end
+  
+end

data/lib/buttonize/button_set.rb

@@ -0,0 +1,98 @@
+module Buttonize
+  class ButtonSet
+  
+    class << self
+      # Define a buttonset
+      #
+      # ==== Options
+      # :style_file:: The style definition file to load
+      # :style_set:: The styleset to use, defaults to :default
+      # :target_path:: The output directory
+      # --
+      def define(options={},&block)
+        @@set = self.new(options)
+        yield @@set
+        @@set
+      end
+    
+      def current
+        @@set
+      end
+    end 
+
+    attr_reader :groups, :buttons, :options
+    attr_accessor :path
+  
+    def initialize(options)
+      defaults = {:style_set => :default}
+      @options = defaults.update(options)
+      @buttons = []
+      @groups = []
+      @path = ""
+      @parent = nil
+    end
+    
+    def group(name,options={})
+      group = self.class.new({}.update(self.options).update(options))
+      group.path = File.join(self.path,name)
+      yield group
+      @groups << group
+      group
+    end
+  
+    def button(text,*opts)
+      button = {:text => text, :options => {}}
+      button[:options] = opts.pop if opts.last.kind_of?(Hash)
+      button[:filename] = opts.pop if opts.last.kind_of?(String)
+      @buttons << button
+      button
+    end
+  
+    # Generate all buttons recursively,
+    # all options set in define can be overruled here.
+    # --
+    def generate(options)
+      # Don't run this when we're in cli mode
+      return if Buttonize.cli?
+      generate_buttons(options)
+    end
+  
+    protected
+
+    def generate_buttons(options)
+      current_options = self.options.merge(options)
+  
+      require current_options[:style_file] if current_options[:style_file]
+      styleset = Buttonize::StyleSet.sets[current_options[:style_set]]
+  
+      # 1. Generate my own buttons
+      self.buttons.each do |button|
+        button_options = button[:options].dup
+    
+        # Determine target path
+        button_options[:target_path] = File.join(current_options[:target_path],self.path) unless button_options[:target_path]
+    
+        # Merge with group options
+        button_options = current_options.merge(button_options)
+
+        # Merge with style options
+        style_name = button_options.delete(:style)
+        button_options = styleset.styles[style_name].merge(button_options) if styleset.styles.has_key?(style_name)
+    
+        Button.new(button_options).generate(button[:text],button[:filename])
+      end
+  
+      # 2. Generate buttons of my groups
+      self.groups.each do |group| 
+        # Create target path
+        if File.directory?(current_options[:target_path]) && !File.directory?(File.join(current_options[:target_path],group.path))
+          FileUtils.mkdir_p(File.join(current_options[:target_path],group.path))
+        end
+    
+        # Generate buttons
+        group.send(:generate_buttons,options)
+      end      
+    end
+    
+  end
+end

data/lib/buttonize/cli.rb

@@ -0,0 +1,58 @@
+require 'thor'
+
+module Buttonize
+
+  class CLI < Thor
+  
+    desc "generate BUTTONSET", "Generates a whole bunch of buttons from a ButtonSet file"
+    method_options :target_path => :optional, # The target where to put the generated buttons, defaults to PWD + "buttons"
+                   :style_file => :optional, # The styleset file to load. Defaults to default built-in styles
+                   :style_set => :optional # The styleset to use. Defaults to "default"
+    def generate(buttonset)
+      options = self.options.inject({}){|mem,h| mem[h[0].to_sym] = h[1]; mem}
+        
+      target_path = options[:target_path]
+      if !target_path
+        target_path = File.join(Dir.pwd,"buttons")
+        FileUtils.mkdir_p(target_path) if !File.directory?(target_path)
+      end
+    
+      options[:target_path] ||= target_path
+    
+      Buttonize.run_in_cli!
+        
+      # Load the buttonset
+      require buttonset    
+      raise "Are you sure #{buttonset} is a buttonset file?" if !ButtonSet.current
+      
+      puts "Generating buttons...."
+      ButtonSet.current.send(:generate_buttons,options)
+    end
+  
+    desc "button TEXT [OUTFILE]", "Generates a single button with TEXT on it, it sanitizes the text to generate filename"
+    method_options :style_file => :optional, # The styleset file to load. Defaults to default built-in styles
+                   :style_set => :optional, # The styleset to use. Defaults to "default"
+                   :style => :required # The button style to use.
+    def button(text,outfile=nil)
+      options = {"style_file" => File.join(File.dirname(__FILE__),"../../examples/default/styles.rb"), "style_set" => :default}.update(self.options)
+      style = get_style(options["style_file"],options["style_set"],options["style"])
+      Buttonize::Button.new(style).generate(text,outfile)
+    end
+  
+    protected
+  
+    def get_style(file,set,style)
+      style_options = get_styleset(file,set).styles[style.to_sym] 
+      raise "No such style '#{style}' defined in styleset '#{set}'" if style_options.nil?
+      style_options
+    end
+  
+    def get_styleset(file,set)
+      require file
+      set = Buttonize::StyleSet.sets[set.to_sym]
+      raise "No such styleset '#{set}' defined in '#{file}'" if set.nil?
+      set
+    end
+  
+  end
+end

data/lib/buttonize/style_set.rb

@@ -0,0 +1,54 @@
+class Buttonize::StyleSet
+  
+  class Style < Hash
+    def method_missing(meth,*params)
+      if meth.to_s =~ /=$/
+        self[meth.to_s.sub(/=$/,"").to_sym] = params.first
+      elsif self.has_key?(meth)
+        self[meth]
+      else 
+        super(meth,*params)
+      end
+    end    
+  end
+  
+  class << self
+    def define(*opts,&block)
+      options = {}
+      options = opts.pop if opts.last.kind_of?(Hash)
+      name = opts.pop if opts.last.kind_of?(String)
+      name ||= :default
+      set = self.sets[name] = self.new(name,options)
+      yield set
+      set
+    end
+
+    def sets
+      @@sets ||= {}
+    end
+  end 
+
+  attr_reader :name, :styles, :options
+
+  def initialize(name,options={})
+    @name = name
+    @styles = {}
+    @options = options
+  end
+   
+  def style(name,options={})
+    style = Style.new
+    
+    style.update(self.options)
+    if base = options.delete(:based_on)
+      style.update(self.styles[base]) 
+    end
+    style.update(options)
+     
+    yield(style) if block_given?
+    
+    self.styles[name] = style
+  end
+   
+   
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: flurin-buttonize
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Flurin Egger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-23 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: wycats-thor
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+description: 
+email: f.p.egger@gmail.com
+executables: 
+- buttonize
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/buttonize
+- examples/buttons.rb
+- examples/default
+- examples/default/big_blue_left.gif
+- examples/default/big_blue_middle.gif
+- examples/default/big_blue_right.gif
+- examples/default/big_green_left.gif
+- examples/default/big_green_middle.gif
+- examples/default/big_green_right.gif
+- examples/default/big_orange_left.gif
+- examples/default/big_orange_middle.gif
+- examples/default/big_orange_right.gif
+- examples/default/big_red_left.gif
+- examples/default/big_red_middle.gif
+- examples/default/big_red_right.gif
+- examples/default/small_blue_left.gif
+- examples/default/small_blue_middle.gif
+- examples/default/small_blue_right.gif
+- examples/default/small_green_left.gif
+- examples/default/small_green_middle.gif
+- examples/default/small_green_right.gif
+- examples/default/small_orange_left.gif
+- examples/default/small_orange_middle.gif
+- examples/default/small_orange_right.gif
+- examples/default/small_red_left.gif
+- examples/default/small_red_middle.gif
+- examples/default/small_red_right.gif
+- examples/default/styles.rb
+- examples/default/table_blue_left.gif
+- examples/default/table_blue_middle.gif
+- examples/default/table_blue_right.gif
+- examples/default/table_green_left.gif
+- examples/default/table_green_middle.gif
+- examples/default/table_green_right.gif
+- examples/default/table_orange_left.gif
+- examples/default/table_orange_middle.gif
+- examples/default/table_orange_right.gif
+- examples/default/table_red_left.gif
+- examples/default/table_red_middle.gif
+- examples/default/table_red_right.gif
+- lib/buttonize
+- lib/buttonize/button.rb
+- lib/buttonize/button_set.rb
+- lib/buttonize/cli.rb
+- lib/buttonize/style_set.rb
+- lib/buttonize.rb
+- MIT-LICENSE
+- README
+has_rdoc: false
+homepage: http://github.com/flurin/buttonize
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A button generation tool for web applications.
+test_files: []
+