snapimage 0.0.1

data/.autotest

@@ -0,0 +1,3 @@
+Autotest.add_hook :initialize do |at|
+  %w{.git doc log tmp vendor}.each { |ex| at.add_exception(ex) }
+end

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rbenv-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/vendor/bundle

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snapimage.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Wesley Wong
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# Snapimage
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'snapimage'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install snapimage
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/snapimage_generate_config

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+
+options = {
+  file: "snapimage_config.yml",
+  force: false
+}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: snapimage_generate_config local_root public_url [options]"
+
+  opts.separator ""
+  opts.separator "local_root\tPath to the directory where the images will be stored"
+  opts.separator "public_url\tURL at which the images will accessible from"
+
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("-f", "--file FILE", "File to generate (Default: snapimage_config.yml)") do |file|
+    options[:file] = file
+  end
+
+  opts.on("--force", "Overwrites the file if it exists") do
+    options[:force] = true
+  end
+
+  opts.on("-h", "--help", "Display the help screen") do
+    puts opts
+    exit
+  end
+end
+optparse.parse!
+
+unless ARGV.length == 2
+  puts optparse.help
+  exit
+end
+
+local_root = ARGV[0]
+public_url = ARGV[1]
+
+if !options[:force] && File.exists?(options[:file])
+  puts "File '#{options[:file]}' already exists. Use --force if you want to overwrite."
+  puts "Config file not generated."
+  puts
+  puts optparse.help
+  exit
+end
+
+File.open(options[:file], "w") do |f|
+  f.write(<<-EOF
+primary_storage_server: "local"
+storage_servers:
+  -
+    name: "local"
+    type: "LOCAL"
+    local_root: "#{local_root}"
+    public_url: "#{public_url}"
+EOF
+  )
+end
+puts "Config file generated at '#{options[:file]}'."

data/bin/snapimage_server

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+
+options = {
+  port: 54321
+}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: snapimage_server config [options]"
+
+  opts.on("-p", "--port", "Set the port (Default: 54321") do |port|
+    options[:port] = port
+  end
+
+  opts.on("--path PATH", "Set the URL path of the SnapImage API Server (Default: /snapimage_api)") do |path|
+    options[:path] = path
+  end
+
+  opts.on("-h", "--help", "Display the help screen") do
+    puts opts
+    exit
+  end
+end
+optparse.parse!
+
+unless ARGV.length == 1
+  puts optparse.help
+  exit
+end
+options[:config] = ARGV[0]
+
+require "sinatra"
+require "snapimage"
+
+# Make sure the built-in web server runs.
+set :run, true
+
+# Set up Sinatra.
+set :environment, :production
+set :port, options[:port]
+
+use SnapImage::Middleware, options
+
+get "/crossdomain.xml" do
+  <<-XML
+  <?xml version="1.0"?>
+  <!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
+  <cross-domain-policy>
+
+    <allow-access-from domain="*" to-ports="#{options[:port]}" />
+
+  </cross-domain-policy>
+  XML
+end

data/lib/snapimage.rb

@@ -0,0 +1,24 @@
+require "rack"
+require "json"
+require "fileutils"
+require "digest/sha1"
+require "open-uri"
+require "RMagick"
+require "snapimage/version"
+require "snapimage/exceptions"
+require "snapimage/rack/request_file"
+require "snapimage/rack/request"
+require "snapimage/rack/response"
+require "snapimage/image/image"
+require "snapimage/image/image_name_utils"
+require "snapimage/storage/storage_server"
+require "snapimage/storage/storage_server.local"
+require "snapimage/storage/storage"
+require "snapimage/config"
+require "snapimage/server_actions/server_actions.authorize"
+require "snapimage/server_actions/server_actions.generate_image"
+require "snapimage/server_actions/server_actions.sync_resource"
+require "snapimage/server_actions/server_actions.delete_resource_images"
+require "snapimage/server_actions/server_actions.list_resource_images"
+require "snapimage/server"
+require "snapimage/middleware"

data/lib/snapimage/config.rb

@@ -0,0 +1,51 @@
+module SnapImage
+  class Config
+    # Arguments:
+    # * config:: Filename of the YAML or JSOn file to load or a config Hash.
+    #
+    # NOTE: All keys are strings, not symbols.
+    def initialize(config)
+      @raw_config = config
+    end
+
+    def validate_config
+      raise SnapImage::InvalidConfig, 'Missing "primary_storage_server"' unless @config["primary_storage_server"]
+      raise SnapImage::InvalidConfig, 'Missing "storage_servers"' unless @config["storage_servers"]
+      raise SnapImage::InvalidConfig, '"storage_servers" must be an array' unless @config["storage_servers"].is_a? Array
+    end
+
+    def set_config_defaults
+      @config["max_width"] ||= 1024
+      @config["max_height"] ||= 2048
+    end
+
+    def get_config
+      return @config if @config
+      @config = @raw_config
+      if @raw_config.is_a? String
+        ext = File.extname(@raw_config)
+        case ext
+        when ".yml", ".yaml"
+          @config = YAML::load(File.open(@raw_config))
+        when ".json"
+          @config = JSON::parse(File.read(@raw_config))
+        else
+          raise SnapImage::UnknownFileType, "Unknown filetype. Expecting .yaml, .yml, or .json: #{@raw_config}"
+        end
+      end
+
+      raise SnapImage::UnknownConfigType, "Unknown config type. Expecting a filename or hash: #{@config}" unless @config.is_a? Hash
+      validate_config
+      set_config_defaults
+      @config
+    end
+
+    def [](key)
+      get_config[key]
+    end
+
+    def storage
+      @storage ||= SnapImage::Storage.new(get_config["storage_servers"], get_config["primary_storage_server"], get_config["max_width"], get_config["max_height"])
+    end
+  end
+end

data/lib/snapimage/exceptions.rb

@@ -0,0 +1,25 @@
+module SnapImage
+  # Configuration.
+  class InvalidConfig < StandardError; end
+  class InvalidStorageConfig < StandardError; end
+  class UnknownConfigType < StandardError; end
+  class MissingConfig < StandardError; end
+
+  # Authorization.
+  class AuthorizationRequired < StandardError; end
+  class AuthorizationFailed < StandardError; end
+
+  # Request.
+  class BadRequest < StandardError; end
+  class ActionNotImplemented < StandardError; end
+
+  # Files.
+  class UnknownFileType < StandardError; end
+  class FileDoesNotExist < StandardError; end
+
+  # Images.
+  class InvalidImageIdentifier < StandardError; end
+
+  # Resources.
+  class InvalidResourceIdentifier < StandardError; end
+end

data/lib/snapimage/image/image.rb

@@ -0,0 +1,96 @@
+module SnapImage
+  class Image
+    def self.from_path(path, public_url)
+      image = SnapImage::Image.new(public_url)
+      image.set_image_from_path(path)
+      image
+    end
+
+    def self.from_blob(blob)
+      image = SnapImage::Image.new
+      image.set_image_from_blob(blob)
+      image
+    end
+
+    def self.from_image(img)
+      image = SnapImage::Image.new
+      image.set_image_from_image(img)
+      image
+    end
+
+    attr_accessor :public_url
+
+    # Arguments:
+    # * public_url:: Public URL associated with the image
+    def initialize(public_url = nil)
+      @public_url = public_url
+    end
+
+    # Arguments:
+    # * path:: Local path or URL
+    def set_image_from_path(path)
+      @image = Magick::ImageList.new(path)
+    end
+
+    # Arguments:
+    # * blob:: Image blob
+    def set_image_from_blob(blob)
+      @image = Magick::ImageList.new
+      @image.from_blob(blob)
+    end
+
+    # Arguments:
+    # * image:: RMagick Image
+    def set_image_from_image(image)
+      @image = image
+    end
+
+    def width
+      @image.columns
+    end
+
+    def height
+      @image.rows
+    end
+
+    def blob
+      @image.to_blob
+    end
+
+    # Crops the image with the given parameters and returns a SnapImage::Image
+    # object.
+    #
+    # Arguments:
+    # * x:: x coordinate of the top left corner
+    # * y:: y coordinate of the top left corner
+    # * width:: width of the crop rectangle
+    # * height:: height of the crop rectangle
+    def crop(x, y, width, height)
+      SnapImage::Image.from_image(@image.crop(x, y, width, height))
+    end
+
+    # Generates a new resized image and returns it as a SnapImage::Image object.
+    #
+    # Arguments:
+    # * width:: Width to resize to
+    # * height:: Height to resize to (optional)
+    # * maintain_aspect_ratio:: If true, the image will be resized to fit within the width/height specified while maintaining the aspect ratio. If false, the image is allowed to be stretched.
+    def resize(width, height = nil, maintain_aspect_ratio = true)
+      raise "Height must be specified when not maintaining aspect ratio." if !maintain_aspect_ratio && !height
+      # If no height is given, make sure it does not interfere with the
+      # resizing.
+      height ||= [width, @image.rows].max
+      if maintain_aspect_ratio
+        SnapImage::Image.from_image(@image.resize_to_fit(width, height))
+      else
+        SnapImage::Image.from_image(@image.resize(width, height))
+      end
+    end
+
+    # Generates a new sharpened image and returns it as a SnapImage::Image
+    # object.
+    def sharpen
+      SnapImage::Image.from_image(@image.sharpen)
+    end
+  end
+end

data/lib/snapimage/image/image_name_utils.rb

@@ -0,0 +1,131 @@
+module SnapImage
+  class ImageNameUtils
+    # Base Image Format:
+    # {basename}-{original dimensions}.{extname}
+    #
+    # Modified Image Format:
+    # {basename}-{original dimensions}-{crop}-{dimensions}-{sharpen}.{extname}
+    #
+    # Notes
+    # * crop:: {x}x{y}x{width}x{height}
+    # * dimensions:: {width}x{height}
+    # * sharpen:: 0 or 1
+    IMAGE_PATH_REGEXP = /^(.*\/|)(([a-z0-9]{8})-(\d+)x(\d+)(-(\d+)x(\d+)x(\d+)x(\d+)-(\d+)x(\d+)-([01])|).(png|jpg|gif))$/
+
+    class << self
+      # Returns true if the path is for a base image. False otherwise.
+      #
+      # The path points to a base image if the dimensions are the same as the
+      # original dimensions, there is no cropping, and there is no sharpening.
+      def base_image?(path)
+        get_image_name_parts(path)[:is_base]
+      end
+
+      # Returns the extension name of the path. Normalizes jpeg to jpg.
+      def get_image_type(path)
+        type =  File.extname(path).sub(/^\./, "")
+        type = "jpg" if type == "jpeg"
+        type
+      end
+
+      # Returns true if the name is valid. False otherwise.
+      def valid?(path)
+        get_image_name_parts(path)
+        return true
+      rescue
+        return false
+      end
+
+      # Parses the following format:
+      # {basename}-{original dimensions}-{crop}-{dimensions}-{sharpen}.{extname}
+      # Notes about the format:
+      # * crop:: {x}x{y}x{width}x{height}
+      # * dimensions:: {width}x{height}
+      # * sharpen:: 0 or 1
+      #
+      # Returns the information in a hash.
+      def get_image_name_parts(path)
+        matches = path.match(SnapImage::ImageNameUtils::IMAGE_PATH_REGEXP)
+        raise SnapImage::InvalidImageIdentifier, "The image identifier is invalid: #{path}" unless matches
+        parts = {
+          is_base: matches[6].size == 0,
+          full: matches[0],
+          path: matches[1].sub(/\/$/, ""),
+          filename: matches[2],
+          basename: matches[3],
+          original_dimensions: [matches[4].to_i, matches[5].to_i],
+          extname: matches[14]
+        }
+        unless parts[:is_base]
+          parts.merge!({
+            crop: {
+              x: matches[7].to_i,
+              y: matches[8].to_i,
+              width: matches[9].to_i,
+              height: matches[10].to_i
+            },
+            dimensions: [matches[11].to_i, matches[12].to_i],
+            sharpen: !!matches[13]
+          })
+        end
+        parts
+      end
+
+      # Returns the base image name from the path.
+      def get_base_image_path(path)
+        parts = get_image_name_parts(path)
+        "#{parts[:path]}/#{parts[:basename]}-#{parts[:original_dimensions][0]}x#{parts[:original_dimensions][1]}.#{parts[:extname]}"
+      end
+
+      # Returns the name with the new width and height.
+      def get_resized_image_name(name, width, height)
+        parts = SnapImage::ImageNameUtils.get_image_name_parts(name)
+        if parts[:is_base]
+          resized_name = SnapImage::ImageNameUtils.generate_image_name(width, height, parts[:extname], basename: parts[:basename])
+        else
+          options = {
+            basename: parts[:basename],
+            crop: parts[:crop],
+            width: width,
+            height: height,
+            sharpen: parts[:sharpend]
+          }
+          resized_name = SnapImage::ImageNameUtils.generate_image_name(parts[:original_dimensions][0], parts[:original_dimensions][1], parts[:extname], options)
+        end
+        resized_name
+      end
+
+      # Generates a random alphanumeric string of 8 characters.
+      def generate_basename
+        (0...8).map { rand(36).to_s(36) }.join
+      end
+
+      # When no options besides :basename are given, generates a base image
+      # name in the format:
+      # {basename}-{original dimensions}.{extname}
+      #
+      # Otherwise, generates a modified image name in the format:
+      # {basename}-{original dimensions}-{crop}-{dimensions}-{sharpen}.{extname}
+      #
+      # Notes about the format:
+      # * crop:: {x}x{y}x{width}x{height}
+      # * dimensions:: {width}x{height}
+      # * sharpen:: 0 or 1
+      #
+      # Options:
+      # * basename:: Defaults to a randomly generated basename of 8 characters
+      # * crop:: Crop values {x: <int>, y: <int>, width: <int>, height: <int>}
+      # * width:: New width
+      # * height:: New height
+      # * sharpen:: True or false
+      def generate_image_name(original_width, original_height, extname, options = {})
+        basename = options.delete(:basename) || self.generate_basename
+        if options.empty?
+          "#{basename}-#{original_width}x#{original_height}.#{extname}"
+        else
+        "#{basename}-#{original_width}x#{original_height}-#{options[:crop][:x]}x#{options[:crop][:y]}x#{options[:crop][:width]}x#{options[:crop][:height]}-#{options[:width]}x#{options[:height]}-#{options[:sharpen] ? 1 : 0}.#{extname}"
+        end
+      end
+    end
+  end
+end