inkcite 1.0.0

data/assets/init/source.txt

@@ -0,0 +1,6 @@
+This is the plain-text version of your email.
+
+<% if production? %>
+This email was sent to [email].  {a id="unsubscribe" href=#}Click here to unsubscribe{/a}.
+Using ERB, this unsubscribe notice will only appear in the 'email' format of this project.
+<% end %>

data/bin/inkcite

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'inkcite'
+require 'inkcite/cli/base'
+
+Inkcite::Cli::Base.start

data/inkcite.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'inkcite/version'
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "inkcite"
+  spec.version       = Inkcite::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ["Jeffrey D. Hoffman"]
+  spec.email         = ["inkcite@inkceptional.com"]
+  spec.description   = "An opinionated modern, responsive HTML email generator with integrated helpers, versioning, live previews, minification and testing."
+  spec.summary       = "Simplifying email development"
+  spec.homepage      = "https://github.com/inkceptional/inkcite"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/) - [".gitignore", "Gemfile", "Gemfile.lock"]
+  spec.executables   << 'inkcite'
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # Sorry, not yet
+  spec.has_rdoc = false
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'builder'
+  spec.add_dependency 'erubis'
+  spec.add_dependency 'faker'
+  spec.add_dependency 'litmus'
+  spec.add_dependency 'mail'
+  spec.add_dependency 'net-sftp'
+  spec.add_dependency 'rack'
+  spec.add_dependency 'rubyzip'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'yui-compressor'
+
+  spec.add_development_dependency "bundler", "~> 1.1"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+
+end

data/lib/inkcite.rb

@@ -0,0 +1,32 @@
+require 'erubis'
+require 'i18n'
+require 'set'
+require 'uri'
+require 'yaml'
+
+require 'active_support/core_ext/hash/keys.rb'  # Symbolize keys!
+require 'active_support/core_ext/module/delegation.rb'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/starts_ends_with'
+
+require 'inkcite/version'
+require 'inkcite/email'
+require 'inkcite/util'
+require 'inkcite/view'
+require 'inkcite/minifier'
+require 'inkcite/parser'
+require 'inkcite/renderer'
+
+module Inkcite
+
+  def self.asset_path
+    File.expand_path('../../..', File.dirname(__FILE__))
+  end
+
+end
+
+# Make sure only available locales are used. This will be the default in the
+# future but we need this to silence a deprecation warning from 0.6.9
+I18n.config.enforce_available_locales = true

data/lib/inkcite/cli/base.rb

@@ -0,0 +1,128 @@
+require 'thor'
+require 'fileutils'
+
+module Inkcite
+  module Cli
+    class Base < Thor
+
+      desc 'build [options]', 'Build the static email assets for deployment'
+      option :archive,
+          :aliases => '-a',
+          :desc => 'The name of the archive to compress final assets into'
+      option :force,
+          :aliases => '-f',
+          :desc => 'Build even if there are errors (not recommended)',
+          :type => :boolean
+
+      def build
+        require_relative 'build'
+        Cli::Build.invoke(email, {
+            :archive => options['archive'],
+            :force => options['force']
+        })
+      end
+
+      desc 'init NAME [options]', 'Initialize a new email project in the NAME directory'
+      option :from,
+          :aliases => '-f',
+          :desc => 'Clones an existing Inkcite project into a new one'
+
+      def init name
+        require_relative 'init'
+        Cli::Init.invoke(name, options)
+      end
+
+      desc 'preview TO [options]', 'Send a preview of the email  recipient list: developer, internal or client'
+
+      def preview to=:developer
+        require_relative 'preview'
+        Cli::Preview.invoke(email, to, options)
+      end
+
+      desc 'server [options]', 'Start the preview server'
+      option :environment,
+          :aliases => '-e',
+          :default => 'development',
+          :desc => 'The environment Inkcite will run under'
+      option :format,
+          :aliases => '-f',
+          :default => 'email',
+          :desc => 'The format Inkcite will display - either email, browser or text'
+      method_option :host,
+          :type => :string,
+          :aliases => '-h',
+          :default => '0.0.0.0',
+          :desc => 'The ip address Inkcite will bind to'
+      method_option :port,
+          :aliases => '-p',
+          :default => '4567',
+          :desc => 'The port Inkcite will listen on',
+          :type => :numeric
+      option :version,
+          :aliases => '-v',
+          :desc => 'Render a specific version of the email'
+
+      def server
+        require_relative 'server'
+
+        Cli::Server.start(email, {
+            :environment => environment,
+            :format => format,
+            :host => options['host'],
+            :port => options['port'],
+            :version => version
+        })
+
+      end
+
+      desc 'test [options]', 'Tests (or re-tests) the email with Litmus'
+      option :new,
+          :aliases => '-n',
+          :desc => 'Forces a new test to be created, otherwise will revision an existing test if present',
+          :type => :boolean
+
+      def test
+        require_relative 'test'
+        Cli::Test.invoke(email, options)
+      end
+
+      desc 'upload', 'Upload the preview version to your CDN or remote image server'
+      option :force,
+          :aliases => '-f',
+          :desc => "Forces files to be uploaded regardless of whether or not they've changed",
+          :type => :boolean
+      def upload
+        options[:force] ? email.upload! : email.upload
+      end
+
+      private
+
+      # Resolves the desired environment (e.g. :development or :preview)
+      # from Thor's commandline options.
+      def environment
+        options['environment'] || :development
+      end
+
+      def email
+        Email.new(Dir.pwd)
+      end
+
+      # Resolves the desired format (e.g. :browser or :email) from Thor's
+      # commandline options.
+      def format
+        options['format'] || :email
+      end
+
+      # Resolves the desired version (typically blank or :default) from
+      # Thor's commandline options.
+      def version
+        options['version']
+      end
+
+      def view
+        email.view(environment, format, version)
+      end
+
+    end
+  end
+end

data/lib/inkcite/cli/build.rb

@@ -0,0 +1,130 @@
+module Inkcite
+  module Cli
+    class Build
+
+      def self.invoke email, opts
+
+        errors = false
+
+        # Don't allow production files to be built if there are errors.
+        email.views(:production) do |ev|
+
+          ev.render!
+
+          if !ev.errors.blank?
+            puts "The #{ev.version} version (#{ev.format}) has #{ev.errors.size} errors:"
+            puts " - #{ev.errors.join("\n - ")}"
+            errors = true
+          end
+
+        end
+
+        abort("Fix errors or use --force to build") if errors && !opts[:force]
+
+        # First, compile all assets to the build directory.
+        build_to_dir email, opts
+
+        # No archive? Build to files instead.
+        archive = opts[:archive]
+        build_archive(email, opts) unless archive.blank?
+
+      end
+
+      private
+
+      # Configuration value controlling where the production files will
+      # be created
+      BUILD_PATH = :'build-path'
+
+      def self.build_archive email, opts
+
+        require 'zip'
+
+        # This is the fully-qualified path to the .zip file.
+        zip_file = File.expand_path(opts[:archive])
+        puts "Archiving to #{zip_file} ..."
+
+        # The Zip::File will try to update an existing archive so just blow the old
+        # one away if it still exists.
+        File.delete(zip_file) if File.exists?(zip_file)
+
+        # The absolute path to the build directories
+        build_html_to = build_path(email)
+        build_images_to = build_images_path(email)
+
+        Zip::File.open(zip_file, Zip::File::CREATE) do |zip|
+
+          # Add the minified images to the .zip archive
+          if File.exists?(build_images_to)
+            Dir.foreach(build_images_to) do |img|
+              img_path = File.join(build_images_to, img)
+              zip.add(File.join(Inkcite::Email::IMAGES, img), img_path) unless File.directory?(img_path)
+            end
+          end
+
+          Dir.foreach(build_html_to) do |file|
+            file_path = File.join(build_html_to, file)
+            zip.add(file, file_path)
+          end
+
+        end
+
+        # Remove the build directory
+        FileUtils.rm_rf(build_html_to)
+
+      end
+
+      def self.build_to_dir email, opts
+
+        # The absolute path to the build directories
+        build_html_to = build_path(email)
+        build_images_to = build_images_path(email)
+
+        puts "Building to #{build_html_to}"
+
+        # Sanity check to ensure we're not building to the same
+        # directory as we're working.
+        if File.identical?(email.path, build_html_to)
+          puts "Working path and build path can not be the same.  Change the '#{BUILD_PATH}' value in your config.yml."
+          exit(1)
+        end
+
+        # Clear the existing build-to directory so we don't get any
+        # lingering files from the last build.
+        FileUtils.rm_rf build_html_to
+
+        # Remove any existing images directory and then create a new one to
+        # ensure the entire build path exists.
+        FileUtils.mkpath build_images_to
+
+        # Check to see if images should be optimized and if so, perform said
+        # optimization on new or updated images.
+        email.optimize_images if email.optimize_images?
+
+        # For each of the production views, build the HTML and links files.
+        email.views(:production) do |ev|
+
+          File.open(File.join(build_html_to, ev.file_name), 'w') { |f| ev.write(f) }
+
+          # Tracked link CSV
+          File.open(File.join(build_html_to, ev.links_file_name), 'w') { |f| ev.write_links_csv(f) } if ev.track_links?
+
+        end
+
+        # Copy all of the source images into the build directory in preparation
+        # for optimization
+        FileUtils.cp_r(File.join(email.optimized_image_dir, '.'), build_images_to)
+
+      end
+
+      def self.build_path email
+        File.expand_path email.config[BUILD_PATH] || 'build'
+      end
+
+      def self.build_images_path email
+        File.join(build_path(email), Email::IMAGES)
+      end
+
+    end
+  end
+end

data/lib/inkcite/cli/init.rb

@@ -0,0 +1,58 @@
+module Inkcite
+  module Cli
+    class Init
+
+      def self.invoke path, opts
+
+        full_init_path = File.expand_path(path)
+
+        # Sanity check to make sure we're not writing over an existing
+        # Inkcite project.
+        abort "It appears that an Inkcite already exists in #{path}" if File.exists?(File.join(full_init_path, 'config.yml'))
+
+        init_image_path = File.join(path, Inkcite::Email::IMAGES)
+        full_init_image_path = File.join(full_init_path, Inkcite::Email::IMAGES)
+
+        # Create the images directory first because it's the deepest level
+        # of the project structure.
+        FileUtils.mkpath(full_init_image_path)
+
+        puts "Created #{init_image_path}"
+
+        # Check to see if the user specified a --from path that is used to
+        # clone an existing project rather than init a new one.
+        from_path = opts[:from]
+
+        # True if we're initializing a project from the built-in files.
+        is_new = opts[:from].blank?
+
+        # Use the default, bundled path if a from-path wasn't specified.
+        # Verify the path exists
+        from_path = File.join(File.expand_path('../../..', File.dirname(__FILE__)), 'assets', 'init') if is_new
+
+        # Verify that the source directory contains the config.yml file
+        # signifying an existing Inkcite project.
+        abort "Can't find #{from_path} or it isn't an existing Inkcite project" unless File.exists?(File.join(from_path, 'config.yml'))
+
+        # Copy the main Inkcite project files
+        FILES.each do |file|
+          FileUtils.cp File.join(from_path, file), full_init_path
+          puts "Created #{File.join(path, file)}"
+        end
+
+        # Check to see if there are images and copy those as well.
+        from_path = File.join(from_path, Inkcite::Email::IMAGES)
+        if File.exists?(from_path)
+          FileUtils.cp_r(File.join(from_path, '.'), full_init_image_path)
+          puts "Copied images to #{init_image_path}"
+        end
+
+      end
+
+      private
+
+      FILES = %w( config.yml source.html helpers.tsv source.txt )
+
+    end
+  end
+end

data/lib/inkcite/cli/preview.rb

@@ -0,0 +1,30 @@
+require 'inkcite/mailer'
+
+module Inkcite
+  module Cli
+    class Preview
+
+      def self.invoke email, to, opt
+
+        # Push the browser preview(s) up to the server to ensure that the
+        # latest images and "view in browser" versions are available.
+        email.upload
+
+        puts "Sending preview to #{to} ..."
+
+        case to.to_sym
+          when :client
+            Inkcite::Mailer.client(email)
+          when :internal
+            Inkcite::Mailer.internal(email)
+          when :developer
+            Inkcite::Mailer.developer(email)
+          else
+            raise "Invalid preview distribution target"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/inkcite/cli/server.rb

@@ -0,0 +1,123 @@
+require 'webrick'
+require 'rack'
+require 'socket'
+
+module Inkcite
+  module Cli
+    class Server
+
+      def self.start email, opts
+
+        # Port should always be an integer.
+        port = opts[:port].to_i
+        host = opts[:host]
+
+        # Resolve local public IP for mobile device address
+        ip = begin
+          IPSocket.getaddress(Socket.gethostname)
+        rescue
+          nil
+        end
+
+        puts "Inkcite #{Inkcite::VERSION} is starting up ..."
+
+        begin
+          @server = ::WEBrick::HTTPServer.new({
+              :BindAddress => host,
+              :Port => port,
+              :AccessLog => [],
+              :Logger => WEBrick::Log.new(nil, 0)
+          })
+        rescue Errno::EADDRINUSE
+          raise "== Port #{port} is unavailable. Either close the instance of Inkcite already running on #{port} or start this Inkcite instance on a new port with: --port=#{port+1}"
+          exit(1)
+        end
+
+        # Listen to all of the things in order to properly
+        # shutdown the server.
+        %w(INT HUP TERM QUIT).each do |sig|
+          if Signal.list[sig]
+            Signal.trap(sig) do
+              @server.shutdown
+            end
+          end
+        end
+
+        @server.mount "/", Rack::Handler::WEBrick, Inkcite::Cli::Server.new(email, opts)
+
+        puts "Your email is being served at http://#{host}:#{port}"
+        puts "Point your mobile device to http://#{ip}:#{port}" if ip
+
+        @server.start
+
+      end
+
+      def initialize email, opts
+        @email = email
+        @opts = opts
+      end
+
+      def call env
+        begin
+
+          path = env[REQUEST_PATH]
+
+          # If this request is for the root index page, render the email.  Otherwise
+          # render the static asset.
+          if path == REQUEST_ROOT
+
+            # Check for and convert query string parameters to a symolized
+            # key hash so the designer can override the environment, format
+            # and version attributes during a given rendering.
+            # Courtesy of http://stackoverflow.com/questions/21990997/how-do-i-create-a-hash-from-a-querystring-in-ruby
+            params = CGI::parse(env[QUERY_STRING] || '')
+            params = Hash[params.map { |key, values| [ key.to_sym, values[0] || true ] }].symbolize_keys
+
+            # Allow the designer to specify both short- and long-form versions of
+            # the (e)nvironment, (f)ormat and (v)ersion.  Otherwise, use the values
+            # that Inkcite was started with.
+            environment = Util.detect(params[:e], params[:environment], @opts[:environment])
+            format = Util.detect(params[:f], params[:format], @opts[:format])
+            version = Util.detect(params[:v], params[:view], @opts[:version])
+
+            # Timestamp all of the messages from this rendering so it is clear which
+            # messages are associated with this reload.
+            ts = "[#{Time.now.strftime(DATEFORMAT)}]"
+
+            puts ''
+            puts "#{ts} Rendering your email [environment=#{environment}, format=#{format}, version=#{version || 'default'}]"
+
+            view = @email.view(environment, format, version)
+
+            html = view.render!
+
+            unless view.errors.blank?
+              error_count = view.errors.count
+              puts "#{ts} #{error_count} error#{'s' if error_count > 1} or warning#{'s' if error_count > 1}:"
+              puts "#{ts} - #{view.errors.join("\n#{ts} - ")}"
+            end
+
+            [200, {}, [html]]
+          else
+            Rack::File.new(Dir.pwd).call(env)
+
+          end
+
+        rescue Exception => e
+          puts e.message
+          puts e.backtrace.inspect
+        end
+
+      end
+
+      private
+
+      REQUEST_PATH = 'REQUEST_PATH'
+      REQUEST_ROOT = '/'
+      QUERY_STRING = 'QUERY_STRING'
+
+      DATEFORMAT = '%Y-%m-%d %H:%M:%S'
+
+    end
+  end
+end