sprites 0.0.1.pre

data/.gitignore

@@ -0,0 +1,12 @@
+tmp
+coverage
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+doc
+.rvmrc
+
+spec/fixtures/project1/public/images/sprites/*.png
+spec/fixtures/project1/public/stylesheets/sprites/*.css
+

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in sprites.gemspec
+gemspec
+
+platforms :mri_18 do
+  gem 'ruby-debug'
+end
+
+platforms :mri_19 do
+  gem 'ruby-debug19'
+end

data/Rakefile

@@ -0,0 +1,41 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc 'Default: run specs.'
+task :default => :spec
+
+namespace :spec do
+  desc 'Create spec'
+  task :create, :path do |t, args|
+    spec_path = File.join('spec', args[:path].gsub(%r{.rb$}, '_spec.rb'))
+    klass = File.basename(args[:path], File.extname(args[:path])).split('_').map {|s| "#{s[0,1].upcase}#{s[1..-1]}" }.join
+    mkdir_p File.dirname(spec_path)
+
+    spec_doc = <<-EOS
+require 'spec_helper'
+
+describe #{klass} do
+end
+EOS
+
+    File.open(spec_path, 'w+') do |f|
+      f.puts spec_doc
+    end
+
+    puts spec_doc
+  end
+end

data/bin/sprites

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'sprites'
+require 'sprites/cli'
+
+include Sprites
+
+begin
+  options = CommandLineOptionParser.new(ARGV)
+  options.parse
+
+  sprite_definition_file_path = options.definition_file_path
+  configuration = Configuration.new_for_command_line_options(options.options)
+  
+  CliApplication.run(sprite_definition_file_path, configuration)
+rescue CliApplication::DefinitionFileNotFound
+  abort 'No Sprite Definition File found.  Please supply a path or place your definition file in `pwd` or `pwd/config`'
+end

data/features/cli.feature

@@ -0,0 +1,11 @@
+Feature: Creating sprites and stylesheets
+  In order to avoid unnecessary image downloads
+  As a developer
+  I want to be able to generate image sprites
+
+  Scenario: Create some sprites
+    Given a project folder
+    And it contains a sprites dsl definition file
+    And it contains sprite images
+    When I run the executable "sprites"
+    Then I should get valid sprites

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,36 @@
+require 'sprites/test/sprite_generator_tester'
+require 'sprites/cli/command_line_option_parser'
+
+Given(/^a project folder$/) do
+  Dir.chdir 'spec/fixtures/project1'
+end
+
+Given(/^it contains a sprites dsl definition file$/) do
+  has_def = File.exists?('config/sprites.rb') || File.exists?('sprites.rb')
+  has_def.should be_true
+end
+
+Given(/^it contains sprite images$/) do
+  Dir['public/images/sprite_images/**/*.png'].should_not be_empty
+end
+
+When(/^I run the executable "([^"]*)"$/) do |bin|
+  `#{Sprites.gem_root}/bin/#{bin}`
+  $?.to_i.should be(0)
+end
+
+Then(/^I should get valid sprites$/) do
+  options = CommandLineOptionParser.new($*)
+  options.parse
+
+  sprite_definition_file_path = options.definition_file_path
+  configuration = Configuration.new_for_command_line_options(options.options)
+
+  load sprite_definition_file_path
+
+  tester = SpriteGeneratorTester.new(Sprites.application.sprites[:buttons], configuration)
+  tester.should be_accurate
+
+  FileUtils.rm Sprite.sprite_full_path(configuration, Sprites.application.sprites[:buttons])
+  FileUtils.rm Stylesheet.stylesheet_full_path(configuration, Sprites.application.sprites[:buttons].stylesheet)
+end

data/features/support/env.rb

@@ -0,0 +1,5 @@
+$: << File.expand_path('../../../lib', __FILE__)
+$: << File.expand_path('../../../spec', __FILE__)
+
+require 'bundler/setup'
+require 'spec_helper'

data/lib/sprites/application.rb

@@ -0,0 +1,44 @@
+require 'sprites/sprites'
+
+module Sprites
+
+  # This class provides top level access to the Sprites application.
+  # So far, three methods are available:
+  # 1. define (_define_)
+  # 2. sprite (_sprite_)
+  #
+  # Author:: Sam Woodard
+  #
+  # :title:Application
+
+  class Application
+    attr_reader :sprites
+
+    # The +new+ class method initializes the class.
+    # === Example
+    #  sprites = Sprites.new
+    def initialize(configuration = ::Sprites.configuration)
+      @configuration = configuration
+      @sprites = Sprites.new
+    end
+
+    # The +define+ method provides access to the dsl
+    # === Example
+    # Sprites.application.define do
+    #   ...
+    # end
+    def define(&blk)
+      instance_eval(&blk)
+    end
+
+
+    # The +sprite+ method adds sprites to the application
+    # === Example
+    # Sprites.application.define do
+    #   ...
+    # end
+    def sprite(*args, &blk)
+      sprites.add(*args, &blk)
+    end
+  end
+end

data/lib/sprites/cli/cli_application.rb

@@ -0,0 +1,11 @@
+module Sprites
+  class CliApplication
+    class DefinitionFileNotFound < StandardError; end
+
+    def self.run(def_file, configuration)
+      load def_file
+      sprite_generator = ChunkyPngGenerator.new(configuration)
+      sprite_generator.generate(::Sprites.application.sprites)
+    end
+  end
+end

data/lib/sprites/cli/command_line_option_parser.rb

@@ -0,0 +1,70 @@
+require 'optparse'
+require 'pathname'
+
+module Sprites
+  class CommandLineOptionParser < OptionParser
+    PRIMARY_DEF_FILE_LOCATION = 'config/sprites.rb'
+    SECONDARY_DEF_FILE_LOCATION = 'sprites.rb'
+
+    attr_reader :definition_file_path, :options
+
+    def initialize(arguments)
+      @definition_file_path, @arguments = extract_sprite_definition_file_path(arguments.clone)
+      @options = Hash.new
+
+      super do |opts|
+        setup_parser(opts)
+      end
+    end
+
+    def parse
+      super(@arguments)
+    end
+
+    def extract_sprite_definition_file_path(arguments)
+      sprite_def_file_pathname = if arguments[0] =~ %r{^.+\.rb}
+        Pathname.new(arguments.shift)
+      elsif file_exists?('config/sprites.rb')
+        Pathname.new('config/sprites.rb')
+      else
+        raise
+      end
+
+      [sprite_def_file_pathname.realpath.to_s, arguments]
+    rescue
+      raise CliApplication::DefinitionFileNotFound
+    end
+
+    def file_exists?(path)
+      Pathname.new(path).exist?
+    end
+
+    def setup_parser(opts)
+      opts.banner = "Usage: sprites [defintion_file] [options]"
+
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      opts.on("-s", "--sprites_path", <<-EOS
+Define the path to where the sprites should be placed. DEFAULT: 'public/images/sprites'
+      EOS
+      ) do |path|
+        @options[:sprites_path] = path
+      end
+
+      opts.on("-c", "--sprite_stylesheets_path", <<-EOS
+Define the path to where the sprites stylesheets should be placed. DEFAULT: 'public/stylesheets/sprites'
+      EOS
+      ) do |path|
+        @options[:sprite_stylesheets_path] = path
+      end
+
+      opts.on("-p", "--sprite_pieces_path", <<-EOS
+Define the path to where the images needed to build the sprites are stored. DEFAULT: 'public/images/sprite_pieces'
+      EOS
+      ) do |path|
+        @options[:sprite_pieces_path] = path
+      end
+    end
+  end
+end

data/lib/sprites/cli.rb

@@ -0,0 +1,4 @@
+module Sprites
+  autoload :CommandLineOptionParser, "sprites/cli/command_line_option_parser"
+  autoload :CliApplication, "sprites/cli/cli_application"
+end

data/lib/sprites/configuration.rb

@@ -0,0 +1,59 @@
+module Sprites
+  class Configuration
+    FIELDS = %w{backend sprites_path sprite_stylesheets_path sprite_pieces_path}
+
+    DEFAULT_CONFIGURATION = {
+      'backend' => :rmagick,
+      'sprites_path' => 'public/images/sprites',
+      'sprite_stylesheets_path' => 'public/stylesheets/sprites',
+      'sprite_pieces_path' => 'public/images/sprite_images'
+    }
+
+    def initialize
+      DEFAULT_CONFIGURATION.each {|k,v| self.send(k, v)}
+    end
+
+    def configure(&blk)
+      instance_eval(&blk)
+      self
+    end
+
+    FIELDS.each do |meth|
+      eval <<-EVAL
+        def #{meth}(*args)
+          val, *_ = args
+
+          if val
+            @#{meth} = val
+            return self
+          end
+
+          @#{meth}
+        end
+      EVAL
+    end
+
+    alias_method :backend_without_override, :backend
+    def backend_with_override(*args)
+      val, *_ = args
+
+      if val
+        backend_without_override(val)
+        return self
+      end
+
+      backend_without_override && backend_without_override.to_sym
+    end
+    alias_method :backend, :backend_with_override
+
+    def self.new_for_command_line_options(options)
+      config = new
+      options.each do |k, v|
+        if FIELDS.include?(k.to_s)
+          config.send(k, v)
+        end
+      end
+      config
+    end
+  end
+end

data/lib/sprites/core_ext/pathname.rb

@@ -0,0 +1,7 @@
+require 'pathname'
+
+class Pathname
+  def self.wrap(val)
+    val.is_a?(Pathname) ? val : Pathname.new(val)
+  end
+end

data/lib/sprites/notifier.rb

@@ -0,0 +1,9 @@
+module Sprites
+  class Notifier
+    def self.no_configured_or_imlicit_backend(print = true)
+      msg = "We were unable to load your configured backend or any supported backends"
+      $stdout << msg if print
+      msg
+    end
+  end
+end

data/lib/sprites/sprite.rb

@@ -0,0 +1,127 @@
+require 'fileutils'
+require 'pathname'
+require 'sprites/core_ext/pathname'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/object/try'
+require 'sprites/sprite_pieces'
+require 'sprites/sprite_piece'
+require 'sprites/stylesheet'
+
+module Sprites
+  class Sprite
+    class InvalidOrientation < StandardError; end
+    module Orientations
+      VERTICAL = 1
+      HORIZONTAL = 2
+    end
+
+    OPTIONS = [:orientation]
+
+    DEFAULT_OPTIONS = {
+      :orientation => Orientations::VERTICAL
+    }
+
+    attr_reader :name, :sprite_pieces, :stylesheet
+
+    def initialize(name)
+      @name = name
+      @sprite_pieces = SpritePieces.new
+      @options = DEFAULT_OPTIONS.dup
+      set_options
+    end
+
+    def define(*args, &blk)
+      @options = @options.merge args.extract_options!
+      @path ||= Pathname.wrap(path_for_arguments(@options, *args))
+      @stylesheet ||= Stylesheet.new(css_path, self)
+      @options.delete(@path.to_s)
+      set_options
+
+      instance_eval(&blk) if block_given?
+      self
+    end
+
+    def define!
+      define unless is_defined?
+    end
+
+    def is_defined?
+      !@stylesheet.nil?
+    end
+
+    def path
+      define!
+      @path
+    end
+
+    def stylesheet
+      define!
+      @stylesheet
+    end
+
+    def write_stylesheet(configuration, sprite_pieces = @sprite_pieces)
+      path = Stylesheet.stylesheet_full_path(configuration, stylesheet)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open path, 'w+' do |f|
+        f << stylesheet.css(configuration, self, sprite_pieces)
+      end
+    end
+
+    def stylesheet_path
+      define!
+      @stylesheet.path
+    end
+
+    def sprite_piece(options)
+      @sprite_pieces.add(options)
+    end
+
+    def orientation(*args)
+      val, *_ = args
+      if val
+        unless [Orientations::VERTICAL, Orientations::HORIZONTAL].include?(val)
+          raise InvalidOrientation
+        end
+        @orientation = val
+        return self
+      end
+
+      @orientation
+    end
+
+    def self.sprite_full_path(configuration, sprite)
+      File.join(configuration.sprites_path, sprite.path)
+    end
+
+    def self.sprite_css_path(configuration, sprite)
+      "/#{sprite_full_path(configuration, sprite)}"
+    end
+
+    private
+
+    def css_path
+      @paths && @paths.last || @path.to_s.gsub(/png$/, 'css')
+    end
+
+    def paths_for_options(options)
+      @paths ||= options.find {|k,v| k.is_a?(String) }
+    end
+
+    def path_for_arguments(options, *args)
+      if args.first.is_a?(Symbol) || (args.empty? && !paths_for_options(options).try(:first))
+        "#{args.first || @name}.png"
+      elsif args.first.is_a?(String)
+        args.first
+      else
+        path = paths_for_options(options).first
+        raise ArgumentError, "Path is not a string.  See usage." unless path.is_a?(String)
+        path
+      end
+    end
+
+    def set_options
+      return unless @options
+      @options.each {|k,v| send(k,v) if Sprite::OPTIONS.include?(k) }
+    end
+  end
+end

data/lib/sprites/sprite_generators/chunky_png_generator.rb

@@ -0,0 +1,114 @@
+begin
+  require 'oily_png'
+rescue
+  require 'chunky_png'
+end
+
+module Sprites
+  class ChunkyPngGenerator
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+    
+    def generate(sprites)
+      # verbose = ENV['VERBOSE'] == 'true' || ENV['DEBUG']
+      #       
+      # if verbose
+      #   t = Time.now
+      #   $stdout << "#{t}: Active Sprites: \"I'm starting my run using #{runner_name}.\"\n" 
+      #   $stdout << "\nSprites to create:\n\"#{@sprites.map(&:path).join('", "')}\"\n"
+      # end
+    
+      sprites.each do |sprite|
+        next if sprite.sprite_pieces.empty?
+        # 
+        # if verbose
+        #   t_sprite = Time.now
+        #   $stdout << "\n=================================================\n"
+        #   $stdout << "Starting Sprite, #{sprite.path}\n"
+        # end
+        # 
+
+        sprite_path = File.join(configuration.sprites_path, sprite.path)
+        sprite_stylesheet_path = File.join(configuration.sprite_stylesheets_path, sprite.stylesheet_path)
+        
+        orientation = sprite.orientation
+        sprite_pieces = sprite.sprite_pieces
+        
+        begin
+        #   $stdout << "Gathering sprite details..." if verbose
+          image_list, width, height = create_image_list(sprite, sprite_path, sprite_pieces, orientation)
+        #   $stdout << "done.\n" if verbose
+        # 
+        #   if ENV['DEBUG']
+        #     $stdout << "|\tpath\t|\tselectors\t|\tx\t|\ty\t|\twidth\t|\theight\t|\n"
+        #     $stdout << "#{sprite_pieces.map(&:to_s).join("\n")}\n"
+        #   end
+        # 
+          sprite.write_stylesheet(configuration)
+        #   stylesheet_file_path = File.join(@railtie.config.paths.public.to_a.first, sprite_stylesheet_path)
+        #   $stdout << "Writing stylesheet to #{stylesheet_file_path} ... " if verbose
+        #   stylesheet.write stylesheet_file_path
+        #   $stdout << "done.\n" if verbose
+        # 
+        #   $stdout << "Beginning sprite generation using #{runner_name.humanize}.\n" if verbose
+          create_sprite(sprite, sprite_path, sprite_pieces, image_list, width, height, orientation, false)
+        #   $stdout << "Success!\n" if verbose
+        # 
+        #   $stdout << "Writing sprite to #{sprite_file_path} ... " if verbose
+          write sprite_path
+        #   $stdout << "done.\n" if verbose
+        # 
+        #   $stdout << "Finished #{sprite.path} in #{Time.now - t_sprite} seconds.\n" if verbose
+        #   $stdout << "=================================================\n\n" if verbose
+        ensure
+          finish
+        end
+      end
+
+      # $stdout << "#{Time.now}: ActiveSprites \"I finished my run in #{Time.now - t} seconds.\"\n" if verbose
+    end
+
+    private
+
+    def create_image_list(sprite, sprite_path, sprite_pieces, orientation)
+      width, height = 0, 0
+
+      image_list = sprite_pieces.map do |sp|
+        sprite_piece_path = SpritePiece.sprite_piece_full_path(@configuration, sp)
+        sp_image =  ChunkyPNG::Image.from_file(sprite_piece_path)
+        sp.x = orientation == Sprite::Orientations::VERTICAL ? 0 : width
+        sp.y = orientation == Sprite::Orientations::VERTICAL ? height : 0
+        sp.width = sp_image.width
+        sp.height = sp_image.height
+
+        width = orientation == Sprite::Orientations::HORIZONTAL ? width + sp_image.width : [width, sp_image.width].max
+        height = orientation == Sprite::Orientations::VERTICAL ? height + sp_image.height : [height, sp_image.height].max
+
+        sp_image
+      end
+      [image_list, width, height]
+    end
+
+    def create_sprite(sprite, sprite_path, sprite_pieces, image_list, width, height, orientation, verbose)
+      @sprite = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+
+      image_list.each_with_index do |image, i|
+        @sprite.replace!(image, sprite_pieces.element_at(i).x, sprite_pieces.element_at(i).y)
+        # $stdout << '.' if verbose
+      end
+      # $stdout << "\n" if verbose
+    end
+
+    def write(path, quality = nil)
+      FileUtils.mkdir_p(File.dirname(path))
+      @sprite.save(path)
+    end
+
+    def finish
+      @sprite = nil
+    end
+  end
+end

data/lib/sprites/sprite_piece.rb

@@ -0,0 +1,36 @@
+module Sprites
+  class SpritePiece
+    attr_reader :path
+    attr_accessor :sprite, :css_selector, :x, :y, :width, :height
+    alias_method :selector, :css_selector
+
+    def initialize(path)
+      @path = path
+    end
+
+    def self.sprite_piece_full_path(configuration, sprite_piece)
+      File.join(configuration.sprite_pieces_path, sprite_piece.path)
+    end
+
+    def css(configuration = ::Sprites.configuration, sprite = @sprite, sprite_css_path = nil)
+      raise "Sprite needed." unless sprite
+
+      <<-CSS
+#{selector}
+{
+  display:block;
+  width:#{width}px;
+  height:#{height}px;
+  background:url('#{sprite_css_path || Sprite.sprite_css_path(configuration, sprite)}') no-repeat #{negative_pixelize(x)} #{negative_pixelize(y)};
+}
+      CSS
+    end
+
+    private
+
+    def negative_pixelize(val)
+      return "0" if val.to_i == 0
+      "-#{val}px"
+    end
+  end
+end

data/lib/sprites/sprite_pieces.rb

@@ -0,0 +1,47 @@
+require 'active_support/ordered_hash'
+
+module Sprites
+  class SpritePieces
+    def initialize
+      @sprite_pieces = ActiveSupport::OrderedHash.new do |sprite_pieces, path|
+        sprite_pieces[path] = SpritePiece.new(path)
+      end
+    end
+
+    def add(options)
+      path, css_selector = options.find {|k,v| k.is_a?(String)}
+      @sprite_pieces[path].css_selector = css_selector
+      @sprite_pieces[path]
+    end
+
+    def count
+      @sprite_pieces.size
+    end
+
+    def empty?
+      @sprite_pieces.empty?
+    end
+
+    def [](val)
+      @sprite_pieces.has_key?(val) ?
+        @sprite_pieces[val] :
+        nil
+    end
+
+    def element_at(index)
+      @sprite_pieces.values[index]
+    end
+
+    def map(*args, &blk)
+      @sprite_pieces.values.map(*args, &blk)
+    end
+
+    def find(*args, &blk)
+      @sprite_pieces.values.find(*args, &blk)
+    end
+
+    def css(configuration = ::Sprites.configuration, sprite = @sprite)
+      @sprite_pieces.values.map {|sp| sp.css(configuration, sprite)}.join("\n")
+    end
+  end
+end