multi_sync 0.0.1

data/lib/multi_sync/extensions/rails/asset_sync.rb

@@ -0,0 +1,44 @@
+module MultiSync
+  module Extensions
+    class AssetSync
+      class << self
+        def asset_sync_yml_exists?
+          ::Rails.root.nil? ? false : File.exist?(asset_sync_yml_path)
+        end
+
+        def asset_sync_yml_path
+          ::Rails.root.join('config', 'asset_sync.yml')
+        end
+
+        def asset_sync_yml
+          @asset_sync_yml ||= YAML.load_file(asset_sync_yml_path)[MultiSync.env]
+        end
+
+        def check_and_migrate
+          return unless self.asset_sync_yml_exists?
+          MultiSync.info 'AssetSync YAML file found, migrating options...'
+
+          MultiSync.source(:rails,
+            type: :manifest,
+            source_dir: MultiSync::Extensions::Rails.source_dir
+          )
+
+          MultiSync.target(:assets,
+            type: asset_sync_yml['fog_provider'],
+            target_dir: asset_sync_yml['fog_directory'],
+            destination_dir: MultiSync::Extensions::Rails.destination_dir,
+            credentials: {
+              region: asset_sync_yml['region'],
+              aws_access_key_id: asset_sync_yml['aws_access_key_id'],
+              aws_secret_access_key: asset_sync_yml['aws_secret_access_key'],
+              path_style: asset_sync_yml['path_style']
+            }
+          )
+
+          MultiSync.delete_abandoned_files = asset_sync_yml['existing_remote_files'] == 'delete'
+          MultiSync.run_on_build = asset_sync_yml['run_on_precompile']
+        end
+      end
+    end
+  end
+end

data/lib/multi_sync/extensions/rails/railtie.rb

@@ -0,0 +1,11 @@
+module MultiSync
+  module Extensions
+    class Railtie < Rails::Railtie
+      railtie_name :multi_sync
+
+      rake_tasks do
+        load 'tasks/multi_sync_rails.rake'
+      end
+    end
+  end
+end

data/lib/multi_sync/logging.rb

@@ -0,0 +1,60 @@
+require 'logger'
+
+module MultiSync
+  module Logging
+    MUTEX = Mutex.new
+
+    def logger
+      @logger || initialize_logger
+    end
+
+    def logger=(new_logger)
+      @logger = new_logger ? new_logger : Logger.new('/dev/null')
+    end
+
+    def status_logger
+      @status_logger || initialize_status_logger
+    end
+
+    def status_logger=(new_status_logger)
+      @status_logger = new_status_logger ? new_status_logger : nil
+    end
+
+    def say_status(status, message, log_status = true)
+      return if status_logger.nil?
+
+      if defined?(Thor) && status_logger.is_a?(Thor)
+        MUTEX.synchronize do
+          status_logger.say_status status, message, log_status
+        end
+      end
+    end
+
+    def log(message, level = :debug)
+      # We're in verbose mode so disable all non-info logs
+      return if !MultiSync.verbose && level != :info
+
+      MUTEX.synchronize do
+        logger.send(level, message)
+      end
+    end
+
+    # Create methods for the different shorthand log methods
+    [:info, :debug, :warn, :error].each do |log_method|
+      # Shorthand log method
+      define_method log_method do |message|
+        send(:log, message, log_method)
+      end
+    end
+
+    private
+
+    def initialize_logger
+      @logger = ::Logger.new(STDOUT)
+    end
+
+    def initialize_status_logger
+      @status_logger = nil
+    end
+  end
+end

data/lib/multi_sync/mixins/log_helper.rb

@@ -0,0 +1,9 @@
+module MultiSync
+  module Mixins
+    module LogHelper
+      def class_name
+        self.class.name.split('::').last
+      end
+    end
+  end
+end

data/lib/multi_sync/mixins/pluralize_helper.rb

@@ -0,0 +1,15 @@
+module MultiSync
+  module Mixins
+    module PluralizeHelper
+      def pluralize(n, singular, plural = nil, prefix = true)
+        if n == 1
+          (prefix ? '1 ' : '') + singular
+        elsif plural
+          (prefix ? "#{n} " : '') + plural
+        else
+          (prefix ? "#{n} " : '') + "#{singular}s"
+        end
+      end
+    end
+  end
+end

data/lib/multi_sync/resource.rb

@@ -0,0 +1,84 @@
+require 'virtus'
+require 'pathname'
+require 'digest/md5'
+require 'multi_sync/mixins/log_helper'
+
+module MultiSync
+  class Resource
+    include Virtus
+    include Comparable
+    include MultiSync::Mixins::LogHelper
+
+    attribute :file, File
+    attribute :path_with_root, Pathname
+    attribute :path_without_root, Pathname
+
+    attribute :etag, String
+    attribute :mtime, Time
+    attribute :content_length, Numeric
+    attribute :content_type, String
+    attribute :digest, String
+
+    AWS_ATTRIBUTES = [{
+      name: :storage_class,
+      type: String,
+      default_value: 'STANDARD'
+    }, {
+      name: :acl,
+      type: String,
+      default_value: 'public-read'
+    }, {
+      name: :expires,
+      type: String,
+      default_value: nil
+    }, {
+      name: :cache_control,
+      type: String,
+      default_value: nil
+    }, {
+      name: :encryption,
+      type: String,
+      default_value: nil
+    }]
+
+    AWS_ATTRIBUTES.each do |attribute_hash|
+      send(:attribute, attribute_hash[:name], attribute_hash[:type])
+    end
+
+    # Initialize a new Resource object
+    #
+    # @param options [Hash]
+    def initialize(options = {})
+      fail(ArgumentError, 'with_root must be present') unless options[:with_root]
+      fail(ArgumentError, 'without_root must be present') unless options[:without_root]
+      self.path_with_root = options.fetch(:with_root)
+      self.path_without_root = options.fetch(:without_root)
+      self.etag = options.fetch(:etag, determine_etag)
+      self.mtime = options.fetch(:mtime, determine_mtime)
+      self.content_length = options.fetch(:content_length, determine_content_length)
+      self.content_type = options.fetch(:content_type, determine_content_type)
+      self.digest = options.fetch(:digest, '')
+
+      AWS_ATTRIBUTES.each do |attribute_hash|
+        send("#{attribute_hash[:name]}=".to_sym, options.fetch(attribute_hash[:name], attribute_hash[:default_value]))
+      end
+    end
+
+    def hash
+      path_without_root.hash
+    end
+
+    def <=>(other)
+      path_without_root <=> other.path_without_root
+    end
+
+    def ==(other)
+      path_without_root == other.path_without_root
+    end
+    alias_method :eql?, :==
+
+    def matching_etag?(other)
+      etag == other.etag
+    end
+  end
+end

data/lib/multi_sync/resources/local_resource.rb

@@ -0,0 +1,30 @@
+require 'multi_mime'
+require 'multi_sync/resource'
+
+module MultiSync
+  class LocalResource < Resource
+    def body
+      File.read(path_with_root.to_s)
+    rescue
+      return nil
+    end
+
+    def determine_etag
+      body.nil? ? nil : Digest::MD5.hexdigest(body)
+    end
+
+    def determine_mtime
+      File.mtime(path_with_root.to_s)
+    rescue
+      return nil
+    end
+
+    def determine_content_type
+      MultiMime.type_for_path(path_with_root.to_s)
+    end
+
+    def determine_content_length
+      body.nil? ? 0 : Fog::Storage.get_body_size(body)
+    end
+  end
+end

data/lib/multi_sync/resources/remote_resource.rb

@@ -0,0 +1,32 @@
+require 'multi_sync/resource'
+
+module MultiSync
+  class RemoteResource < Resource
+    def initialize(options = {})
+      self.file = options.fetch(:file, nil)
+      super(options)
+    end
+
+    def body
+      file.body
+    end
+
+    def determine_etag
+      file.etag
+    rescue NoMethodError # Fog::Storage::Local::File's don't have an etag method :(
+      Digest::MD5.hexdigest(File.read(path_with_root))
+    end
+
+    def determine_mtime
+      file.last_modified
+    end
+
+    def determine_content_type
+      file.content_type
+    end
+
+    def determine_content_length
+      file.content_length
+    end
+  end
+end

data/lib/multi_sync/source.rb

@@ -0,0 +1,40 @@
+require 'virtus'
+require 'pathname'
+require 'lazily'
+require 'multi_sync/mixins/log_helper'
+
+module MultiSync
+  class Source
+    include Virtus
+    include MultiSync::Mixins::LogHelper
+
+    attribute :targets, Array, default: []
+    attribute :source_dir, String
+    attribute :source_options, Hash
+    attribute :include, String
+    attribute :exclude, String
+
+    # Initialize a new Source object
+    #
+    # @param options [Hash]
+    def initialize(options = {})
+      fail(ArgumentError, 'source_dir must be a present') unless options[:source_dir]
+      targets.concat([*options.fetch(:targets, [])])
+      self.source_dir = options.fetch(:source_dir).to_s
+      source_dir << '/' unless source_dir.end_with?('/')
+      self.source_dir = Pathname.new(source_dir)
+      self.include = options.fetch(:include, '**/*')
+      self.exclude = options.fetch(:exclude, nil)
+    end
+
+    private
+
+    def path_to_local_resource(path, options = {})
+      pathname = Pathname.new(path)
+      MultiSync::LocalResource.new({
+        with_root: pathname,
+        without_root: pathname.relative_path_from(source_dir).cleanpath
+      }.merge(options).merge(source_options))
+    end
+  end
+end

data/lib/multi_sync/sources/local_source.rb

@@ -0,0 +1,17 @@
+require 'multi_sync/source'
+require 'multi_sync/resources/local_resource'
+
+module MultiSync
+  class LocalSource < Source
+    def files
+      files = []
+      included_files = Dir.glob(source_dir + include)
+      excluded_files = exclude.nil? ? [] : Dir.glob(source_dir + exclude)
+      (included_files - excluded_files).lazily.each { |path|
+        next if File.directory?(path)
+        files << path_to_local_resource(path)
+      }
+      files
+    end
+  end
+end

data/lib/multi_sync/sources/manifest_source.rb

@@ -0,0 +1,82 @@
+require 'yaml'
+require 'multi_json'
+require 'multi_sync/source'
+require 'multi_sync/resources/local_resource'
+
+module MultiSync
+  class ManifestSource < Source
+    def files
+      files = []
+      manifest_hash = {}
+
+      # ::ActionView::Base has a shortcut to the manifest file
+      # otherwise lets hunt down that manifest file!
+      if defined?(::ActionView::Base) && ::ActionView::Base.respond_to?(:assets_manifest)
+        manifest_hash = ::ActionView::Base.assets_manifest.files
+      else
+        manifest_path = locate_manifest(source_dir)
+        manifest_hash = parse_manifest(manifest_path)
+      end
+
+      # create a local_resource from each file
+      # making sure to skip any that do not match the include/exclude patterns
+      manifest_hash.lazily.each { |key, value|
+        path = source_dir + key
+        next if !path.fnmatch?(include.to_s) or path.fnmatch?(exclude.to_s || '')
+        file = path_to_local_resource(path, mtime: value['mtime'], digest: value['digest'], content_length: value['size'])
+        files << file
+      }
+
+      files
+    end
+
+    private
+
+    def locate_manifest(dir)
+      Dir.glob(dir.to_s + 'manifest*.{json,yaml,yml}').max { |f| File.ctime(f) }
+    end
+
+    def parse_manifest(manifest_path)
+      manifest_hash = {}
+      manifest_data = File.read(manifest_path)
+
+      # manifest files can be YAML or JSON but Sprockets::Manifest isn't backwards compatible with that in mind :(
+      case File.extname(manifest_path)
+      when '.json'
+        manifest_hash = MultiJson.load(manifest_data)
+      when '.yml', '.yaml'
+        manifest_hash = YAML.load(manifest_data)
+      end
+
+      # different versions of Sprockets have different manifest layouts, lets try and work around this by checking for the presence of "files" and "assets" in the manifest first
+      # else we know it must be an old manifest file, so its root is "files"
+      if manifest_hash.key?('files') || manifest_hash.key?('assets')
+        manifest_hash = manifest_hash['files']
+      else
+
+        # index.* files are special and should be ignored from sync
+        # something which seems to only happen in older versions of Sprockets
+        manifest_hash.delete_if { |key, value|
+          key.include?('/index.')
+        }
+
+        # lets manipulate this older manifest to appear similiar to the newer manifest's "files"
+        modified_manifest_hash = {}
+        manifest_hash.each { |key, value|
+          modified_manifest_hash[value] = {
+            'logical_path' => key,
+            'mtime' => nil,
+            'size' => nil,
+            'digest' => nil
+          }
+        }
+
+        #
+        manifest_hash = modified_manifest_hash
+
+      end
+
+      manifest_hash
+    end
+  end
+end

data/lib/multi_sync/target.rb

@@ -0,0 +1,34 @@
+require 'fog'
+require 'lazily'
+require 'virtus'
+require 'pathname'
+require 'celluloid'
+require 'multi_sync/mixins/log_helper'
+
+module MultiSync
+  class Target
+    include Virtus
+    include Celluloid
+    include MultiSync::Mixins::LogHelper
+
+    attribute :connection
+    attribute :target_dir, Pathname
+    attribute :destination_dir, Pathname
+    attribute :credentials, Hash, default: :default_credentials
+
+    # Initialize a new Target object
+    #
+    # @param options [Hash]
+    def initialize(options = {})
+      fail(ArgumentError, 'target_dir must be present') unless options[:target_dir]
+      self.target_dir = Pathname.new(options.fetch(:target_dir, ''))
+      self.destination_dir = Pathname.new(options.fetch(:destination_dir, ''))
+      credentials.merge!(options.fetch(:credentials, {}))
+    end
+
+    def default_credentials
+      # deep clone just in case
+      Marshal.load(Marshal.dump(MultiSync.credentials))
+    end
+  end
+end