gallerize-cli 0.2.2 → 0.3.0

data/app/assets/stylesheets/styles.scss

@@ -0,0 +1,2 @@
+@import 'jquery.fancybox';
+@import 'gallerize';

data/app/config/gallerize_cli.yml

@@ -0,0 +1,28 @@
+site_title: Gallerize Title
+site_url: '.'
+output_path: gallerize
+
+images_per_page: 40
+
+file_patterns:
+  - "*.jpg"
+  - "*.png"
+  - "*.gif"
+
+versions:
+  thumb:
+    width: 400
+    height: 250
+    approach: crop
+
+  large:
+    width: 1000
+    height: 800
+    approach: resize
+
+parallel:
+  in_processes: 6
+
+image_attributes:
+  example.jpg:
+    title: The Title

data/app/templates/layout.html.haml

@@ -0,0 +1,37 @@
+!!!
+%html{"xml:lang" => "en", :xmlns => "http://www.w3.org/1999/xhtml"}
+  %head
+    %meta{:content => "text/html;charset=UTF-8", "http-equiv" => "Content-Type"}/
+    %meta{:content => "noindex", :name => "robots"}/
+    %meta{:content => "noindex", :name => "googlebot"}/
+
+    %script{src: javascripts_min_path, type: 'text/javascript'}
+    %link{href: stylesheets_min_path, media: 'screen', rel: 'stylesheet', type: 'text/css'}
+
+    %meta{:content => "width=device-width, user-scalable=no", :name => "viewport"}/
+
+    %title= config.site_title
+
+  %body
+    %h1.page-title= config.site_title
+    #images-container
+      - if total_pages > 1
+        .navigation
+          %ul
+            %li{class: "#{'active' if current_page == 1}"}
+              %a{href: site_url('index.html')} 1
+            - total_pages.times do |i|
+              %li{class: "#{'active' if current_page == i + 2}"}
+                %a{href: site_url("page-#{i + 2}.html")}= i + 2
+
+      .images
+        - images.each do |image|
+          .image
+            .image-inner
+              - title = capture_haml do
+                %a.original-link{href: image.original_url, target: :blank } Download Full Resolution
+              %a.image-link.fancybox{rel: 'group', href: image.large_url, title: title, data: {original: image.original_url} }
+                %img{src: image.thumb_url }
+              .image-title
+                %a.original-link{href: image.original_url, target: :blank }
+                  = image.attributes['title'] || image.name

data/bin/{gallerize → gallerize_cli}

@@ -1,8 +1,11 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 require "pathname"
-
 bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
 $:.unshift File.expand_path("../../lib", bin_file)
 
-require 'gallerize'
+require 'gallerize_cli'
+
+GallerizeCli.perform

data/gallerize-cli.gemspec

@@ -1,26 +1,26 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "gallerize"
+require "gallerize_cli"
 
 Gem::Specification.new do |s|
-  s.name        = "gallerize-cli"
-  s.version     = Gallerize::VERSION
-  s.authors     = ["Blake Hilscher"]
-  s.email       = ["blake@hilscher.ca"]
-  s.homepage    = "http://blake.hilscher.ca/"
-  s.license     = "MIT"
-  s.summary     = "Generate a static gallery from a folder of images."
+  s.name = "gallerize-cli"
+  s.version = GallerizeCli::VERSION
+  s.authors = ["Blake Hilscher"]
+  s.email = ["blake@hilscher.ca"]
+  s.homepage = "http://blake.hilscher.ca/"
+  s.license = "MIT"
+  s.summary = "Generate a static gallery from a folder of images."
   s.description = "https://github.com/blakehilscher/gallerize"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = ["gallerize"]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = ["gallerize_cli"]
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency  'mini_magick', '3.7.0'
-  s.add_runtime_dependency  'activesupport', '4.1.1'
-  s.add_runtime_dependency  'parallel', '1.0.0'
-  s.add_runtime_dependency  'exifr', '1.1.3'
+  s.add_runtime_dependency 'mini_magick', '3.7.0'
+  s.add_runtime_dependency 'parallel', '1.0.0'
+  s.add_runtime_dependency 'sass', '3.4.7'
+  s.add_runtime_dependency 'uglifier'
 
   s.add_development_dependency "pry", "~> 0.9"
 end

data/lib/gallerize_cli/directory.rb

@@ -0,0 +1,113 @@
+require 'fileutils'
+require 'gallerize_cli/image'
+require 'sass'
+require 'sass/engine'
+require 'uglifier'
+require 'parallel'
+
+module GallerizeCli
+  class Directory
+    include FileUtils::Verbose
+
+    attr_reader :root_path
+
+    def initialize(path)
+      @root_path = File.expand_path(path)
+    end
+
+    def process
+      install
+      Parallel.each(images, in_processes: config.parallel['in_processes']) do |image|
+        image.process
+      end
+    end
+
+    def total_images_count
+      images.count
+    end
+
+    def images
+      @images ||= load_images
+    end
+
+    def config
+      @config ||= OpenStruct.new(YAML.load(File.read(File.join(app_install_path, 'config/gallerize_cli.yml'))))
+    end
+
+    def assets_path
+      @assets_path ||= File.join(output_path, 'assets')
+    end
+
+    def images_path
+      @images_path ||= File.join(output_path, 'images')
+    end
+
+    def output_path
+      @output_path ||= File.expand_path(config.output_path)
+    end
+
+    def app_install_path
+      File.join(root_path, '.gallerize_cli')
+    end
+
+    def javascripts_min_path
+      @javascripts_min_path ||= compile_javascripts.gsub(output_path, config.site_url)
+    end
+
+    def stylesheets_min_path
+      @stylesheets_min_path ||= compile_stylesheets.gsub(output_path, config.site_url)
+    end
+
+    private
+
+    def compile_javascripts
+      # compile files
+      load_path = File.join(app_install_path, 'assets/javascripts')
+      output = Dir.glob(File.join(load_path, '**/*.js')).collect do |js_file|
+        Uglifier.new.compile(File.read(js_file))
+      end.join
+      # write minified file
+      output_file = File.join(assets_path, "gallerize_cli-#{Digest::MD5.hexdigest(output)}.min.js")
+      GallerizeCli.logger.debug("generated #{output_file}")
+      File.write(output_file, output)
+      output_file
+    end
+
+    def compile_stylesheets
+      # configure load_paths
+      load_path = File.join(app_install_path, 'assets/stylesheets')
+      # this is undefined for some unknown reason
+      Sass.define_singleton_method(:load_paths) { [load_path] }
+      # compile styles.scss
+      scss_file = File.join(load_path, 'styles.scss')
+      source = File.read(scss_file)
+      output = Sass::Engine.new(source, style: :compressed, syntax: :scss).render
+      # write new file
+      output_file = File.join(assets_path, "gallerize_cli-#{Digest::MD5.hexdigest(output)}.min.css")
+      GallerizeCli.logger.debug("generated #{output_file}")
+      File.write(output_file, output)
+      output_file
+    end
+
+    def load_images
+      output = []
+      Dir.chdir(root_path) do
+        config.file_patterns.each do |file_pattern|
+          Dir.glob(file_pattern) do |file_path|
+            output << GallerizeCli::Image.new(self, file_path)
+          end
+        end
+      end
+      output
+    end
+
+    def install
+      cp_r(GallerizeCli.app_source_path, app_install_path) unless Dir.exists?(app_install_path)
+      mkdir_p(output_path) unless Dir.exists?(output_path)
+      mkdir_p(images_path) unless Dir.exists?(images_path)
+      mkdir_p(assets_path) unless Dir.exists?(assets_path)
+      cp_r(File.join(app_install_path, 'assets/images'), File.join(assets_path))
+    end
+
+  end
+end

data/lib/gallerize_cli/image/version.rb

@@ -0,0 +1,99 @@
+require 'mini_magick'
+require 'exifr'
+
+module GallerizeCli
+  class Image
+    class Version
+      include FileUtils::Verbose
+
+      attr_accessor :image, :name, :options
+
+      def initialize(image, name, options)
+        @image = image
+        @name = name
+        @options = OpenStruct.new(options)
+        @valid = true
+      end
+
+      def process
+        generate
+      end
+
+      def url
+        file_path.to_s.gsub(image.directory.output_path, config.site_url)
+      end
+
+      def file_path
+        @file_path ||= load_file_path
+      end
+
+      def width
+        options.width.to_i
+      end
+
+      def height
+        options.height.to_i
+      end
+
+      def valid?
+        !!@valid
+      end
+
+      def config
+        image.config
+      end
+
+      private
+
+      def generate
+        # do we have width and height?
+        if width <= 0 || height <= 0
+          GallerizeCli.logger.debug "version: #{name} is missing width: #{width} or height: #{height}"
+
+        elsif !File.exists?(file_path)
+          GallerizeCli.logger.debug "generating #{options.approach} #{file_path}"
+          # open it up
+          mini_image = MiniMagick::Image.open(image.file_path)
+          mini_image.auto_orient
+          if options.approach == 'crop'
+            crop(mini_image, width, height)
+          else
+            resize(mini_image, width, height)
+          end
+          # landscape?
+          mini_image.write file_path
+        end
+      rescue => err
+        @valid = false
+        GallerizeCli.logger.debug "#{err} image.file_name: #{image.file_name} name: #{name} options: #{options}"
+      end
+
+      def resize(mini_image, width, height)
+        if mini_image[:width] > mini_image[:height]
+          mini_image.resize "#{width}x#{height}>"
+        else
+          # portrait
+          mini_image.resize "#{height}x#{width.to_i * 1.25}"
+        end
+      end
+
+      def crop(mini_image, width, height)
+        max = width > height ? width : height
+        if mini_image[:width] > mini_image[:height]
+          resize(mini_image, max * 2, height)
+        else
+          resize(mini_image, width, max * 2)
+        end
+
+        mini_image.crop "#{width}x#{height}+0+0"
+      end
+
+      def load_file_path
+        path = File.join(image.directory.images_path, name)
+        mkdir_p(path) unless Dir.exists?(path)
+        File.join(path, image.file_name)
+      end
+
+    end
+  end
+end

data/lib/gallerize_cli/image.rb

@@ -0,0 +1,87 @@
+require 'gallerize_cli/image/version'
+
+module GallerizeCli
+  class Image
+    include FileUtils::Verbose
+
+    attr_reader :directory, :file_path, :versions
+
+    class << self
+
+      def generate_version_method(name)
+        unless public_method_defined?("#{name}_url")
+          define_method("#{name}_url") { self.versions[name].url }
+        end
+      end
+
+    end
+
+    def attributes
+      @attributes ||= fetch_attributes
+    end
+
+    def original_url
+      destination = File.join(directory.images_path, file_name)
+      cp(file_path, destination) unless File.exists?(destination)
+      destination.gsub(directory.output_path, config.site_url)
+    end
+
+    def initialize(directory, file_path)
+      @success = true
+      @directory = directory
+      @file_path = file_path
+      generate_version_methods
+    end
+
+    def process
+      versions.each { |name, version| version.process }
+    end
+
+    def name
+      return @name if defined?(@name)
+      parts = file_name.split('.')
+      parts.pop
+      @name = parts.join('.')
+    end
+
+    def file_name
+      @file_name ||= File.basename(file_path)
+    end
+
+    def config
+      directory.config
+    end
+
+    def versions
+      @versions ||= config.versions.inject({}) do |hash, (version_name, options)|
+        hash[version_name] = GallerizeCli::Image::Version.new(self, version_name, options)
+        hash
+      end
+    end
+
+    def valid?
+      versions.collect(&:valid?).include?(false)
+    end
+
+    private
+
+    def fetch_attributes
+      hash = {}
+      if config.image_attributes.is_a?(Hash)
+        hash = config.image_attributes[file_name] || {}
+      end
+      OpenStruct.new(hash)
+    end
+
+    def generate_version_methods
+      versions.each do |name, version|
+        self.class.generate_version_method(name)
+      end
+    end
+
+    def success?
+      @success
+    end
+
+  end
+end

data/lib/gallerize_cli/render.rb

@@ -0,0 +1,70 @@
+require 'haml'
+require 'forwardable'
+
+module GallerizeCli
+  class Render
+
+    attr_accessor :directory
+
+    def initialize(directory)
+      @directory = directory
+    end
+
+    def perform
+      index = 1
+      directory.images.each_slice(directory.config.images_per_page) do |images|
+        file = File.join(directory.output_path, 'index.html')
+        file = File.join(directory.output_path, "page-#{index}.html") if index != 1
+        View.new(directory, file, {images: images, page_index: index}).render
+        index += 1
+      end
+    end
+
+    def output_file
+      File.join(directory.output_path, 'index.html')
+    end
+
+    class View
+      extend Forwardable
+
+      attr_reader :directory, :file_path, :locals
+
+      def_delegators :@directory, :javascripts_min_path, :stylesheets_min_path, :config, :total_images_count
+
+      def initialize(directory, file_path, locals={})
+        @directory = directory
+        @file_path = file_path
+        @locals = locals
+      end
+
+      def render
+        GallerizeCli.logger.debug("generate #{file_path}")
+        File.write(file_path, Haml::Engine.new(template).render(self, locals))
+      end
+
+      def site_url(path=nil)
+        File.join(config.site_url, path)
+      end
+
+      def current_page
+        (locals[:page_index] + 1 / directory.config.images_per_page)
+      end
+
+      def total_pages
+        directory.total_images_count / directory.config.images_per_page
+      end
+
+      private
+
+      def template
+        @template ||= File.read(File.join(templates_path, 'layout.html.haml'))
+      end
+
+      def templates_path
+        @templates_path ||= File.join(directory.app_install_path, 'templates')
+      end
+
+    end
+
+  end
+end