ralber 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b60444e1324682dac3a7d030dff87746500e2c2
+  data.tar.gz: bcbc2b32ad77e4b91af37be4661e81b8350fb8cb
+SHA512:
+  metadata.gz: 1487111943be6a4f493c756c6dcbd1df162a90d4cd5b287beac10d013ad2f971aad2e674f7f29d217466fe2ce2de390930f87f71563a79adfbcc4e6a1a537386
+  data.tar.gz: 6676c3917f20fd98dc1415f42f71b2bb73398e777f09f3ee0b6bd9e871818fe06affe59893f6a06e264f2383adfcf382df0433ace81b75a789e55719362bcd39

data/bin/ralber.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("..", __FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+require 'commander/import'
+require 'ralber/commands/create_command'
+require 'ralber/commands/publish_command'
+require 'ralber/commands/update_command'
+
+program :version, '0.0.1'
+program :description, 'A static web album generator'
+ 
+command :create do |c|
+  c.syntax = 'ralber create [options]'
+  c.summary = 'Initializes the current folder as an Album.'
+  c.description = 'creates an initial album.json and grabs image information for all images found in the directory.'
+  c.example 'Simple create', 'ralber create'
+  c.option '--title STRING', String, 'Sets the album title. Defaults to the current folder name'
+  c.option '--subtitle STRING', String, 'Sets the album subtitle.'
+  c.option '--description STRING', String, 'Sets the album description.'
+  c.when_called Ralber::Commands::Create
+end
+
+command :publish do |c|
+  c.syntax = 'ralber publish [options]'
+  c.summary = 'Publishes an existing album: Copies the images and web content, and generates the dynamic files.'
+  c.description = ''
+  c.option '--template STRING', String, 'Name or path to a Template'
+  c.option '--to STRING',String, 'Destination path to which the web album is published'
+  c.option '--save',String, 'If set, the album.json is updated with the delivered command line options, like publish path'
+  c.option '--force', 'If set, all images are (re-)created, even if they already exist in the destination. Default is to not override any images.'
+  c.example 'Simple publish', 'ralber publish --to /path/to/final/destination'
+  c.when_called Ralber::Commands::Publish
+end
+
+command :update do |c|
+  c.syntax = 'ralber update [options]'
+  c.summary = 'Updates the actual album.'
+  c.description = 'Updates the album.json file with new / removed images, and updates image information.'
+  c.example 'Simple update', 'ralber update'
+  c.when_called Ralber::Commands::Update
+end
+

data/lib/ralber/album.rb

@@ -0,0 +1,215 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'json'
+require 'ralber/image'
+require 'ralber/observable'
+
+module Ralber
+    class Album
+        include Observable
+
+        attr :path
+        attr_reader :title, :subtitle, :description, :destination, :images, :template, :album_info
+        attr_writer :title, :subtitle, :description, :destination, :template
+
+        def initialize(path)
+            raise IOError, "directory does not exist: #{path}" if not Dir.exists?(path)
+            @path = File.expand_path(path)
+            @album_info = self.get_album_info
+            @images = self.collect_images(@album_info['images'])
+        end
+
+        def title
+            return @album_info['title']
+        end
+
+        def title=(value)
+            @album_info['title'] = value
+            self
+        end
+
+        def subtitle
+            return @album_info['subtitle']
+        end
+        def subtitle=(value)
+            @album_info['subtitle'] = value
+            self
+        end
+
+        def destination
+            return @album_info['destination']
+        end
+        def destination=(value)
+            @album_info['destination'] = value
+            self
+        end
+
+        def description
+            return @album_info['description']
+        end
+        def description=(value)
+            @album_info['description'] = value
+            self
+        end
+
+        def template
+            return @album_info['template']
+        end
+        def template=(value)
+            @album_info['template'] = value
+            self
+        end
+
+        def author
+            return @album_info['author']
+        end
+
+        def author=(value)
+            @album_info['author'] = value
+            self
+        end
+
+        def copyright
+            return @album_info['copyright']
+        end
+
+        def copyright=(value)
+            @album_info['copyright'] = value
+            self
+        end
+
+
+        ##
+        # creates an album.json file, and invokes the json creation for each
+        # image found in the album
+        def create(options = {})
+            @images = []
+            info = self.get_new_info
+            Dir.entries(@path).find_all { |f| File.file?(File.join(@path,f)) }.map{|f| File.join(@path,f)}.each do |f|
+                begin
+                    img = Image.new(f)
+                    img.create
+                    @images << img
+                    yield img if block_given?
+                    info['images'] << File.basename(f)
+                rescue
+                end
+            end
+
+            @album_info = info
+            (@album_info['title'] = options['title']) if options.key?('title')
+            (@album_info['subtitle'] = options['subtitle']) if options.key?('subtitle')
+            (@album_info['description'] = options['description']) if options.key?('description')
+            (@album_info['author'] = options['author']) if options.key?('author')
+            (@album_info['copyright'] = options['copyright']) if options.key?('copyright')
+            self.write_albuminfo
+        end
+
+        def write_albuminfo
+            FileUtils.mkdir_p(File.dirname self.json_path)
+            images = @images.map {|img| File.basename(img.path)}
+            @album_info['images'] = images
+            open(self.json_path,'w') do |f|
+               f.write(JSON.pretty_generate(@album_info))
+            end
+        end
+
+        def json_path
+            File.expand_path(File.join(@path,'.ralber','album.json'))
+        end
+
+        def get_new_info
+            {
+                "title" => File.basename(@path),
+                "subtitle" => '',
+                "description" => '',
+                "author" => '',
+                "copyright" => '',
+                "images" => [],
+                "template" => nil,
+                "destination" => nil
+            }
+        end
+
+        ##
+        # Reads the album metainfo from the album.json file, if present,
+        # or sets apropriate defaults.
+        def get_album_info
+            info = self.get_new_info
+            if File.exists?(json_path)
+                begin
+                    data = JSON.parse(File.read(json_path))
+                    if data.respond_to?(:key?)
+                        (info['title'] = data['title']) if data.key?('title')
+                        (info['subtitle'] = data['subtitle']) if data.key?('subtitle')
+                        (info['description'] = data['description']) if data.key?('description')
+                        (info['author'] = data['author']) if data.key?('author')
+                        (info['copyright'] = data['copyright']) if data.key?('copyright')
+                        (info['images'] = data['images']) if data.key?('images')
+                        (info['template'] = data['template']) if data.key?('template')
+                        (info['index'] = data['index']) if data.key?('index')
+                        (info['detail'] = data['detail']) if data.key?('detail')
+                        (info['destination'] = data['destination']) if data.key?('destination')
+                    end
+                rescue
+                end
+            end
+            return info
+        end
+
+        ##
+        # fetches all the imags in the album dir, creating Image instances from them
+        # and return an array of Image objects.
+        def collect_images(image_names, folder = nil)
+            folder = @path if not folder
+            images = []
+            image_names.each do | imgname |
+                imgpath = File.join(folder,imgname)
+                begin
+                    img = Image.new(imgpath)
+                    if img.type
+                        images << img
+                        yield img if block_given?
+                    end
+                rescue
+                end
+            end
+            return images
+        end
+
+        def image_index(image) 
+            return @images.index(image)
+        end
+
+        def update
+            img_files = Dir.entries(@path).find_all { |f| File.file?(File.join(@path,f)) }.map{|f| File.join(@path,f)}
+
+            # The following situation could happen:
+            # 1. when the Image object is present, the image config and the file is OK, no action needed.
+            # 2. remaining image files need to be added
+            # 3. orphaned config files need to be removed
+            new_images = []
+            @images.each_with_index do | img, index |
+                # all images in the @images array are still OK and present, we just re-append them:
+                new_images << img
+
+                # remove entry from the found image files, as those are OK:
+                img_files.delete_if {|img_file| File.basename(img_file) == File.basename(img.path)}
+            end
+            @images = new_images
+
+            # remaining image files without album entry: we need to process them as new images:
+            img_files.each do | new_file |
+                begin
+                    img = Image.new(new_file)
+                    self.inform_listeners(:update, "new image found: #{new_file}")
+                    img.create
+                    @images << img
+                rescue
+                end
+            end
+            self.write_albuminfo
+        end
+    end
+end

data/lib/ralber/commands/create_command.rb

@@ -0,0 +1,39 @@
+require 'highline/import'
+require 'ralber/album'
+
+module Ralber
+    module Commands
+        class Create
+            def initialize(args, options) 
+                self.set_defaults(options)
+                @options = options
+                self.ask_title if options.title == nil
+                self.create_album
+            end
+
+            def set_defaults(options)
+                options.default \
+                    :title => nil
+            end
+
+            def ask_title
+                @options.title = ask("Album title? ", String)
+            end
+
+            def create_album
+                puts("Creating album '#{@options.title}' in #{Dir.pwd}")
+                album = Ralber::Album.new(Dir.pwd)
+                album.create({
+                    'title' => @options.title,
+                    'subtitle' => @options.subtitle,
+                    'description' => @options.description
+                }) do |img|
+                    print "."
+                end
+
+                puts("\nDone. Found #{album.images.length} images. You can now edit album.json and/or publish the album.")
+            end
+        end
+
+    end
+end

data/lib/ralber/commands/publish_command.rb

@@ -0,0 +1,72 @@
+require 'highline/import'
+require 'pathname'
+require 'ralber/album'
+require 'ralber/template'
+require 'ralber/publisher'
+
+module Ralber
+    module Commands
+        class Publish
+            def initialize(args, options) 
+                @album = Ralber::Album.new(Dir.pwd)
+                self.set_defaults(options)
+                @options = options
+                self.publish
+            end
+
+            def set_defaults(options)
+                options.default \
+                    :title => nil
+            end
+
+            def configure_template
+                tpl = @options.template
+                tpl = @album.template unless tpl
+                tpl = "default" unless tpl
+                tplObj = nil
+                begin
+                    tplObj = Ralber::Template.new(tpl, File.join(File.dirname(Gem.bin_path('ralber','ralber.rb')),'..','templates'))
+                    @album.template = tpl
+                rescue
+                    puts "Could not find template. Either give the name or path to a template via --template parameter, or put a 'template' config in album.json."
+                    exit 2
+                end
+                return tplObj
+            end
+
+            def configure_destination
+                dest = @options.to
+                dest = @album.destination unless dest
+                
+                if not dest
+                   puts "Please provide a destination path with --to <path>"
+                   exit 2
+                end
+
+                @album.destination = dest
+
+                if not (Pathname.new dest).absolute?
+                    dest = File.join(@album.path,dest)
+                end
+                
+                return dest
+            end
+
+            def publish
+                template = self.configure_template
+                dest = self.configure_destination                
+
+                puts "please wait, work in progress..."
+                publisher = Ralber::Publisher.new(@album, template)
+                publisher.force = @options.force
+                publisher.add_listener(self)
+                publisher.publish_to(dest)
+                publisher.save_album if @options.save
+            end
+
+            def message(context, message)
+                puts message
+            end
+        end
+    end
+end

data/lib/ralber/commands/update_command.rb

@@ -0,0 +1,31 @@
+require 'highline/import'
+require 'pathname'
+require 'ralber/album'
+
+module Ralber
+    module Commands
+        class Update
+            def initialize(args, options) 
+                @album = Ralber::Album.new(Dir.pwd)
+                self.set_defaults(options)
+                @options = options
+                self.update
+            end
+
+            def set_defaults(options)
+                options.default \
+                    :title => nil
+            end
+
+            def update
+                puts "please wait, work in progress..."
+                @album.add_listener(self)
+                @album.update
+            end
+
+            def message(context, message)
+                puts message
+            end
+        end
+    end
+end

data/lib/ralber/image.rb

@@ -0,0 +1,155 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'json'
+require 'rmagick'
+
+module Ralber
+
+    ##
+    # Represents an image with its metadata. Performs also converting
+    # functions like thumbs etc.
+    class Image
+        attr :path
+        attr_reader :title, :type, :description, :width, :height
+
+        def initialize(path)
+            raise StandardError, "File does not exits" if not File.exists?(path)
+            @path = File.expand_path(path)
+            @image_info = self.get_image_info
+        end
+
+        def title
+            @image_info['title']
+        end
+        def type
+            @image_info['type']
+        end
+        def description
+            @image_info['description']
+        end
+        def width
+            @image_info['width']
+        end
+        def height
+            @image_info['height']
+        end
+
+        ##
+        # creates the initial image.json file, extracting the metadata
+        # if possible. If the image is not recognized, an exception is raised.
+        def create
+            @image_info = get_new_info
+            meta = self.image_metadata
+            type = meta[:type]
+            raise StandardError, "Unknown image type" if not type
+            @image_info['type'] = type
+            @image_info['width'] = meta[:width]
+            @image_info['height'] = meta[:height]
+
+            self.write_imageinfo
+        end
+
+        def write_imageinfo
+            FileUtils.mkdir_p(File.dirname json_path)
+            open(self.json_path,'w') do |f|
+                f.write(JSON.pretty_generate(@image_info))
+            end
+        end
+
+        def json_path
+            dir = File.join(File.dirname(@path),'.ralber')
+            base = File.basename(@path)
+            File.expand_path(File.join(dir,base+'.json'))
+        end
+
+        def get_new_info
+            {
+                "title" => File.basename(@path),
+                "type" => nil,
+                "description" => '',
+                "width" => 0,
+                "height" => 0
+            }
+        end
+
+        ##
+        # reads image metainfos from the image file and, if present,
+        # from the image.json file.
+        def get_image_info
+            info = get_new_info
+            if File.exists?(json_path)
+                begin
+                    data = JSON.parse(File.read(json_path))
+                    if data.respond_to?(:key?)
+                        (info['title'] = data['title']) if data.key?('title')
+                        (info['description'] = data['description']) if data.key?('description')
+                        (info['type'] = data['type'].to_sym) if data.key?('type')
+                        (info['width'] = data['width']) if data.key?('width')
+                        (info['height'] = data['height']) if data.key?('height')
+                    end
+                rescue
+                end
+            else
+                self.create
+            end
+            return info
+        end
+
+        def image_type
+            type = FastImage.type(@path)
+            raise StandardError, "Unknown image type" if not type
+            return type
+        end
+
+        def image_dimensions
+            dim = FastImage.size(@path)
+            { :width => dim[0],:height => dim[1] }
+        end
+
+        def image_metadata
+            img = Magick::Image::read(@path).first
+            {
+                :width => img.columns,
+                :height => img.rows,
+                :type => self.map_type(img.format)
+            }
+        end
+
+        def map_type(imagickType)
+            case imagickType
+                when 'JPEG' then :jpeg
+                when 'PNG' then :png
+                when 'GIF' then :gif
+                else nil
+            end
+        end
+
+        def create_resized_image(output_filename, geometry_string = nil)
+            img = Magick::Image::read(@path).first
+            if geometry_string
+                img.change_geometry!(geometry_string) { |cols, rows, manipImg|
+                    img.resize!(cols, rows)
+                }
+            end
+            img.write(output_filename)
+        end
+
+        def create_resized_version(type, geometry_string, output_dir)
+            name = self.get_resized_name(@path, type)
+            outfile = File.join(output_dir,name)
+            self.create_resized_image(outfile,geometry_string)
+        end
+
+        def get_resized_name(path, type)
+            name = File.basename(path,'.*')
+            case type
+                when :jpeg then name += '.jpg'
+                when :jpg then name += '.jpg'
+                when :png then name += '.png'
+                else name = File.basename(path)
+            end
+            return name
+        end
+    end
+end

data/lib/ralber/observable.rb

@@ -0,0 +1,17 @@
+module Ralber
+    module Observable
+    	def add_listener(listener)
+    		@listeners = [] unless @listeners
+    	    @listeners << listener
+    	end
+
+        def inform_listeners(msg_context,message)
+        	if not @listeners.respond_to?(:each)
+        		return;
+        	end
+            @listeners.each { |listener|
+                listener.message(msg_context,message) if listener.respond_to?(:message)
+            }
+        end
+    end
+end