bulldog 0.0.1

data/lib/bulldog/style.rb

@@ -0,0 +1,38 @@
+module Bulldog
+  class Style
+    def initialize(name, attributes={})
+      @name = name
+      @attributes = attributes
+    end
+
+    attr_reader :name, :attributes
+
+    #
+    # Return the value of the given style attribute.
+    #
+    delegate :[], :to => :attributes
+
+    #
+    # Set the value of the given style attribute.
+    #
+    delegate :[]=, :to => :attributes
+
+    #
+    # Return true if the argument is a Style with the same name and
+    # attributes.
+    #
+    def ==(other)
+      other.is_a?(self.class) &&
+        name == other.name &&
+        attributes == other.attributes
+    end
+
+    def inspect
+      "#<Style #{name.inspect} #{attributes.inspect}>"
+    end
+
+    delegate :hash, :eql?, :to => :name
+
+    ORIGINAL = new(:original, {})
+  end
+end

data/lib/bulldog/style_set.rb

@@ -0,0 +1,101 @@
+module Bulldog
+  #
+  # An ordered set of Styles.
+  #
+  # Lookup is by style name.
+  #
+  class StyleSet
+    #
+    # Create a StyleSet containing the given styles.
+    #
+    def initialize(styles=[])
+      @styles = styles.to_a
+    end
+
+    #
+    # Initialize a StyleSet from another.
+    #
+    def initialize_copy(other)
+      super
+      @styles = @styles.clone
+    end
+
+    #
+    # Create a StyleSet containing the given styles.
+    #
+    def self.[](*styles)
+      new(styles)
+    end
+
+    #
+    # Return the style with the given name.
+    #
+    def [](arg)
+      if arg.is_a?(Symbol)
+        if arg == :original
+          Style::ORIGINAL
+        else
+          @styles.find{|style| style.name == arg}
+        end
+      else
+        @styles[arg]
+      end
+    end
+
+    #
+    # Add the given style to the set.
+    #
+    def <<(style)
+      @styles << style
+    end
+
+    #
+    # Return true if the given object has the same styles as this one.
+    #
+    # The argument must have #to_a defined.
+    #
+    def ==(other)
+      other.to_a == @styles
+    end
+
+    #
+    # Return the list of styles as an Array.
+    #
+    def to_a
+      @styles.dup
+    end
+
+    #
+    # Return true if there are no styles in the set, false otherwise.
+    #
+    def empty?
+      @styles.empty?
+    end
+
+    #
+    # Return the style with the given names.
+    #
+    def slice(*names)
+      styles = names.map{|name| self[name]}
+      StyleSet[*styles]
+    end
+
+    #
+    # Clear all styles out of the style set.
+    #
+    # The original will still be retrievable.
+    #
+    def clear
+      @styles.clear
+    end
+
+    #
+    # Yield each style.
+    #
+    def each(&block)
+      @styles.each(&block)
+    end
+
+    include Enumerable
+  end
+end

data/lib/bulldog/tempfile.rb

@@ -0,0 +1,28 @@
+require 'tempfile'
+
+module Bulldog
+  if RUBY_VERSION >= '1.8.7'
+    Tempfile = ::Tempfile
+  else
+    #
+    # Backport Ruby 1.8.7's Tempfile feature which allows specifying the
+    # extension by passing in the path as a 2-element array.  Useful for
+    # things like ImageMagick, which often rely on the file extension.
+    #
+    class Tempfile < ::Tempfile
+      private
+
+      def make_tmpname(basename, n)
+        case basename
+        when Array
+          prefix, suffix = *basename
+        else
+          prefix, suffix = basename, ''
+        end
+
+        t = Time.now.strftime("%Y%m%d")
+        path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+      end
+    end
+  end
+end

data/lib/bulldog/util.rb

@@ -0,0 +1,92 @@
+module Bulldog
+  module Util
+    #
+    # Return the path of the first occurrence of +basename+ in the
+    # current PATH, or nil if the file cannot be found.
+    #
+    def find_in_path(basename)
+      ENV['PATH'].split(/:+/).each do |dirname|
+        path = File.join(dirname, basename)
+        if File.file?(path) && File.executable?(path)
+          return path
+        end
+      end
+      nil
+    end
+
+    #
+    # Run the given command, logging everything obsessively.
+    #
+    # Return the output if the command is successful, nil otherwise.
+    # If an :expect_status option is given, any status codes in the
+    # list are considered successful.
+    #
+    def run(*command)
+      options = command.last.is_a?(Hash) ? command.pop : {}
+      command.map!{|x| x.to_s}
+      command = Shellwords.join(command) + ' 2>&1'
+      Bulldog.logger.info("[Bulldog] Running: #{command}") if Bulldog.logger
+      output = `#{command}`
+      status = $?.exitstatus
+      if Bulldog.logger
+        Bulldog.logger.info("[Bulldog] Output: #{output}")
+        Bulldog.logger.info("[Bulldog] Status: #{status}")
+      end
+      expected_statuses = options[:expect_status] || [0]
+      expected_statuses.include?(status) ? output : nil
+    end
+
+    # Backport Shellwords.join from ruby 1.8.7.
+    require 'shellwords'
+    if ::Shellwords.respond_to?(:join)
+      # ruby >= 1.8.7
+      Shellwords = ::Shellwords
+    else
+      module Shellwords
+        #
+        # Escapes a string so that it can be safely used in a Bourne shell
+        # command line.
+        #
+        # Note that a resulted string should be used unquoted and is not
+        # intended for use in double quotes nor in single quotes.
+        #
+        #   open("| grep #{Shellwords.escape(pattern)} file") { |pipe|
+        #     # ...
+        #   }
+        #
+        def escape(str)
+          # An empty argument will be skipped, so return empty quotes.
+          return "''" if str.empty?
+
+          str = str.dup
+
+          # Process as a single byte sequence because not all shell
+          # implementations are multibyte aware.
+          str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+
+          # A LF cannot be escaped with a backslash because a backslash + LF
+          # combo is regarded as line continuation and simply ignored.
+          str.gsub!(/\n/, "'\n'")
+
+          return str
+        end
+
+        module_function :escape
+
+        #
+        # Builds a command line string from an argument list +array+ joining
+        # all elements escaped for Bourne shell and separated by a space.
+        #
+        #   open('|' + Shellwords.join(['grep', pattern, *files])) { |pipe|
+        #     # ...
+        #   }
+        #
+        def join(array)
+          array.map { |arg| escape(arg) }.join(' ')
+        end
+
+        module_function :join
+      end
+    end
+  end
+end

data/lib/bulldog/validations.rb

@@ -0,0 +1,68 @@
+module Bulldog
+  module Validations
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def validates_attachment_presence_of(name, options={})
+        validates_each(name, options) do |record, attribute, attachment|
+          attachment.present? && attachment.file_size > 0 or
+            record.errors.add attribute, options[:message] || :attachment_blank
+        end
+      end
+
+      def validates_attachment_file_size_of(name, options={})
+        if (range = options.delete(:in))
+          options[:greater_than] = range.min - 1
+          options[:less_than   ] = range.max + 1
+        end
+        validates_each(name, options) do |record, attribute, attachment|
+          if attachment.present?
+            file_size = attachment.file_size
+            if options[:greater_than]
+              file_size > options[:greater_than] or
+                record.errors.add attribute, options[:message] || :attachment_too_small
+            end
+            if options[:less_than]
+              file_size < options[:less_than] or
+                record.errors.add attribute, options[:message] || :attachment_too_large
+            end
+          end
+        end
+      end
+
+      def validates_attachment_type_of(name, options={})
+        validates_each(name, options) do |record, attribute, attachment|
+          if attachment.present?
+            if (pattern = options[:matches])
+              attachment.content_type =~ pattern or
+                record.errors.add attribute, options[:message] || :attachment_wrong_type
+            elsif (specifier = options[:is])
+              if specifier.is_a?(Symbol)
+                attachment_class = Attachment.class_from_type(specifier)
+                attachment.is_a?(attachment_class) or
+                  record.errors.add attribute, options[:message] || :attachment_wrong_type
+              else
+                parse_mime_type = lambda do |string|
+                  mime_type, parameter_string = string.to_s.split(/;/)
+                  parameters = {}
+                  (parameter_string || '').split(/,/).each do |pair|
+                    name, value = pair.strip.split(/=/)
+                    parameters[name] = value
+                  end
+                  [mime_type, parameters]
+                end
+
+                expected_type, expected_parameters = parse_mime_type.call(specifier)
+                actual_type, actual_parameters = parse_mime_type.call(attachment.content_type)
+                expected_type == actual_type && expected_parameters.all?{|k,v| actual_parameters[k] == v} or
+                  record.errors.add attribute, options[:message] || :wrong_type
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bulldog/vector2.rb

@@ -0,0 +1,18 @@
+module Bulldog
+  class Vector2
+    def initialize(object)
+      case object
+      when Array
+        @x, @y = object[0].to_i, object[1].to_i
+      when String
+        match = /([+-]?\d+)[^-+\d]*([+-]?\d+)/.match(object) or
+          raise ArgumentError, "invalid vector: #{object.inspect}"
+        @x, @y = match[1].to_i, match[2].to_i
+      else
+        raise ArgumentError, "cannot convert to vector: #{object.inspect}"
+      end
+    end
+
+    attr_accessor :x, :y
+  end
+end

data/rails/init.rb

@@ -0,0 +1,9 @@
+require 'bulldog'
+
+Bulldog.instance_eval do
+  self.logger = Rails.logger
+
+  to_interpolate(:rails_root){Rails.root}
+  to_interpolate(:rails_env){Rails.env}
+  to_interpolate(:public_path){Rails.public_path}
+end

data/script/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'irb'
+$:.unshift 'lib'
+require 'active_record'
+require 'bulldog'
+require 'init'
+IRB.start

data/spec/helpers/image_creation.rb

@@ -0,0 +1,8 @@
+module ImageCreation
+  def create_image(path, options={})
+    options[:size] ||= '10x10'
+    convert = Bulldog::Processor::ImageMagick.convert_command
+    system(convert, '-geometry', "#{options[:size]}!", 'pattern:checkerboard', path)
+    path
+  end
+end

data/spec/helpers/temporary_directory.rb

@@ -0,0 +1,25 @@
+module TemporaryDirectory
+  def self.included(mod)
+    mod.before{init_temporary_directory}
+    mod.after{remove_temporary_directory}
+  end
+
+  def temporary_directory
+    "#{ROOT}/spec/tmp"
+  end
+
+  private  # ---------------------------------------------------------
+
+  def init_temporary_directory
+    remove_temporary_directory
+    FileUtils.mkdir_p(temporary_directory)
+
+    # When an attachment is deleted, it deletes empty ancestral
+    # directories.  Don't delete past the temporary directory.
+    FileUtils.touch "#{temporary_directory}/.do_not_delete"
+  end
+
+  def remove_temporary_directory
+    FileUtils.rm_rf(temporary_directory)
+  end
+end

data/spec/helpers/temporary_models.rb

@@ -0,0 +1,76 @@
+module TemporaryModels
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  #
+  # Set up a model class with the given name for all examples in this
+  # example group.  +columns+ is a hash from column name to
+  # ActiveRecord type (e.g., :string or :integer).
+  #
+  # The class +name+ may be a String or Symbol.  It can also be a
+  # singleton hash mapping the class name to the superclass name.  If
+  # the superclass is not ActiveRecord::Base, it is assumed to
+  # indicate single table inheritance, and no table will be created.
+  #
+  def create_model_class(name, columns={}, &class_body)
+    if name.is_a?(Hash) && name.size == 1
+      class_name, superclass_name = *name.to_a.flatten
+    else
+      class_name, superclass_name = name, 'ActiveRecord::Base'
+    end
+    need_table = superclass_name.to_s == 'ActiveRecord::Base'
+
+    table_name = class_name.to_s.underscore.pluralize
+    if need_table
+      ActiveRecord::Base.connection.create_table(table_name) do |table|
+        columns.each do |column_name, column_type|
+          table.send column_type, column_name
+        end
+      end
+    end
+    klass = Class.new(superclass_name.to_s.constantize, &class_body)
+    Object.const_set(class_name, klass)
+  end
+
+  #
+  # Destroy a model class created with #create_model_class, and drop
+  # the created table.  +name+ should be the same as the first
+  # argument given on creation.
+  #
+  def destroy_model_class(name)
+    if name.is_a?(Hash) && name.size == 1
+      class_name, superclass_name = *name.to_a.flatten
+    else
+      class_name, superclass_name = name, 'ActiveRecord::Base'
+    end
+    need_table = superclass_name.to_s == 'ActiveRecord::Base'
+
+    table_name = class_name.to_s.underscore.pluralize
+    ActiveRecord::Base.connection.drop_table(table_name) if need_table
+    Object.send(:remove_const, class_name)
+  end
+
+  #
+  # Create a model and table for the duration of the block.  See
+  # #create_model_class for the meaning of the arguments.
+  #
+  def with_model_class(name, columns={})
+    create_model_class(name, columns)
+    yield
+  ensure
+    destroy_model_class(name)
+  end
+
+  module ClassMethods
+    #
+    # Create a model and table for the duration of each example in
+    # this example group.  See #create_model_class for the meaning of
+    # the arguments.
+    #
+    def use_model_class(name, columns={}, &class_body)
+      before{create_model_class(name, columns, &class_body)}
+      after{destroy_model_class(name)}
+    end
+  end
+end