multi_sync 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15f64f882b07eb32c2ab67b3a86aebfce1c41c06
-  data.tar.gz: f35664cd52f5bf38d99156140f0c56aa1aa09e91
+  metadata.gz: 580e01265e2768d6a728b4dc3b29adad42874e7b
+  data.tar.gz: 09575ab0fa096363ef1deeeb94a435e6dc1a5605
 SHA512:
-  metadata.gz: 40c4bfece43530dbc54002bb4b59787bfa59f28acca1085772de7f0a22c83be9577a2b30fe47943d5f25f269b865a1c6fdc3ce55ed327143d80b7414c48cea4e
-  data.tar.gz: 845d7cc8cd79ab528445f057c0957a4802d7dcf4296be83fe99b1697a2867018052cfc8c64f5b5d4d597f29aeb1ecb37bd71c905fa39d8b27c8018b10861884d
+  metadata.gz: 5c729e36efd763755ca1d1f85827fc986a7e90823ab1199c900620d8f012f2f7182ce432d91fdf3292063f3ab74f11a146690814551c074329d33c3653dc2b4f
+  data.tar.gz: 3968ae066b80ef8fb122c7b90aa7817ec1e7b8646091d7ff5af8e9832bcaa9da506e8dc746800664e49df5918bc1874a847e6cc1768c41c37f281a0e8677f81a

data/Gemfile

@@ -7,6 +7,7 @@ gem 'celluloid', github: 'celluloid/celluloid'
 
 group :developement do
   gem 'rubocop', github: 'bbatsov/rubocop'
+  gem 'pry'
 end
 
 group :test do

data/README.md

@@ -1,12 +1,16 @@
 # MultiSync
 
-:heavy_exclamation_mark: **a WIP that is functioning but just a warning, not finished yet.** :heavy_exclamation_mark:
+:heavy_exclamation_mark: **currently a functioning WIP thats not quite finished yet but its close!** :heavy_exclamation_mark:
 
 A flexible synchronisation library for your assets.
 
-At MultiSync's core is [Celluloid](http://celluloid.io) allowing for the synchronisation of assets to be truly parallel. Each target you define creates a pool of resources which allows for parallel execution of uploads and deletes. Meaning that when your synchronising thousands of files, you get alot more :boom: for your :dollar:.
+`MultiSync` stands on the shoulders of giants. On one side is [Celluloid](http://celluloid.io) allowing for the synchronisation of assets to be highly parallel. On the other is [Fog::Storage](https://github.com/fog/fog) allowing `MulitSync` to support [various well known storage services](#storage-services).
 
-MultiSync tries to expose its asset synchronisation in a flexible way, allowing for it to be used in `Rails`, `Sinatra (WIP)`, `Rake (WIP)` and `Plain old ruby` as well as extensions for `Middleman (WIP)`, `Nanoc (WIP)` and others. Listed below are examples of how to get setup.
+What that means is when your configuring `MultiSync` your creating various pools of workers which then distrubute the work behind synchronising your assets. Meaning that when your site has thousands of files, you get alot more :boom: for your :dollar: in less :alarm_clock:.
+
+`MultiSync` tries to expose its asset synchronisation in a flexible way which should allow you to define how and where your assets live. Where possible though, `MultiSync` will try to provide support for [various well known libraries](#supported-libraries).
+
+Listed below are examples of how to get setup and started.
 
 ## Installation
 
@@ -17,7 +21,7 @@ gem 'multi_sync', '~> 0.0.1'
 ```ruby
 require 'multi_sync'
 
-MultiSync.configuration do |config|
+MultiSync.configure do |config|
   # config.verbose = false  # turn on verbose logging (defaults to false)
   # config.force = false  # force syncing of outdated_files (defaults to false)
   # config.run_on_build = true # when within a framework which `builds` assets, whether to sync afterwards (defaults to true)
@@ -25,79 +29,119 @@ MultiSync.configuration do |config|
   # config.delete_abandoned_files = true # when an abondoned file is found whether to remove it (defaults to true)
   # config.upload_missing_files = true # when a missing file is found whether to upload it (defaults to true)
   # config.target_pool_size = 8 # how many threads you would like to open for each target (defaults to the amount of CPU core's your machine has)
-  # config.max_sync_attempts = 1 # how many times a file should be retried if there was an error during sync (defaults to 3)
+  # config.max_sync_attempts = 3 # how many times a file should be retried if there was an error during sync (defaults to 3)
 end
 ```
 
 ### Fog credentials support
 
-`MultiSync` supports utilising [Fog Credentials](http://fog.io/about/getting_started.html#credentials). Simply specify either a `FOG_RC` or `.fog` and we'll use it as the base for any credentials used in a target.
+`MultiSync` supports utilising [Fog Credentials](http://fog.io/about/getting_started.html#credentials). Simply specify either a `FOG_RC` or `.fog` and we'll use it as the base for any `:credentials` used in a `target`.
 
 ## Features / Usage Examples
 
-### AssetSync compatibility
-
-Many people use [AssetSync](https://github.com/rumblelabs/asset_sync) and for `MultiSync`'s first release compatibility with it has been built in. When within a `Rails` environment `MultiSync` will check for `asset_sync.yml` and read in its settings. You should be able to simply require `multi_sync` and try things out.
+`MultiSync` in its simplist form consists of three objects. `sources`, `resources` and `targets`. A `source` defines how and where a list of files (or `resources`) can be found. A `resource` represents a file from a `source` with additional properties (such as how to compare them). A `target` is destination which `resources` can be synchronised against.
 
-#### Unsupported features
+### Source
 
-- `AssetSync`'s environment variables
-- `AssetSync`'s gzip_compression hack
+A source takes two arguments. The first is a `name` to reference this source by and the second is a `Hash` of configuration detailed below.
 
-### Rails
+| Key | Type | Default | Description |
+| :-- | :--- | :------ | :---------- |
+| `type` | `Symbol` | `nil` | The `type` of source this is (`:local`, `:manifest`) |
+| `source_dir` | `Pathname`, `String` | `nil` | The location this source should use |
+| `resource_options` | `Hash` | `nil` | A hash of options for this source`s resources |
+| `targets` | `Symbol`, `Array` | All targets | The target(s) this source should sync against |
+| `include` | `String` ([shell glob](http://www.ruby-doc.org/core-2.1.1/Dir.html#method-c-glob)) | `**/*` | A shell globe to use for inclusion |
+| `exclude` | `String` ([shell glob](http://www.ruby-doc.org/core-2.1.1/Dir.html#method-c-glob)) | `nil` | A shell globe to use for exclusion |
+___
 
-`MultiSync` prefers ruby backed configuration instead of `YAML` so you'll need to create an initializer `/config/initializers/multi_sync` for `MultiSync`.
+```ruby
+# A source named ':build' which is ':local' and will use all files within '../build'
+source :build, {
+  type: :local,
+  source_dir: '../build'
+}
+```
+___
 
 ```ruby
-MultiSync.prepare do
-
-  source :public, {
-    type: :manifest, # load files from a Sprockets based manifest
-    source_dir: '/path_to_your_build_folder',
-    targets: [:assets] # an array of target names that this source should sync against
-  }
-
-  target :assets, {
-    type: :aws, # :aws is the target's type, current options are :aws
-    target_dir: 'your_aws_bucket',
-    destination_dir: 'an_optional_directory_inside_your_aws_bucket',
-    credentials: {
-      region: 'us-east-1',
-      aws_access_key_id: 'super_secret',
-      aws_secret_access_key: 'super_secret'
-    }
-  }
+# A source named ':assets' which will use a Sprockets ':manifest' within '../public/assets'
+source :assets, {
+  type: :manifest,
+  source_dir: '../public/assets'
+}
+```
+___
 
-end
+```ruby
+# A source named ':video_assets' which is `:local' and will use all files
+# within '../build' including only 'mp4, mpg, mov'
+source :video_assets, {
+  type: :local,
+  source_dir: '../build',
+  include: '*.{mp4,mpg,mov}'
+}
 ```
+___
 
-`MultiSync.prepare` simply bootstraps `MultiSync` which is then ran during `rake assets:precompile`. By having `multi_sync` included in your `Gemfile`, the rake task `rake assets:sync` will be available.
+```ruby
+# A source named ':no_images' which is `:local' and will use all files
+# within '../build' excluding any 'jpg, gif, png'
+source :no_images, {
+  type: :local,
+  source_dir: '../build',
+  exclude: '*.{jpg,gif,png}'
+}
+```
+___
 
-### Plain Old Ruby
+```ruby
+# A source named ':www' which will use a Sprockets ':manifest'
+# within '../public/assets' excluding any 'jpg, gif, png' files
+# and only synchronising with a target named `:www`
+source :www, {
+  type: :manifest,
+  source_dir: '../public/assets',
+  exclude: '*.{jpg,gif,png}',
+  targets: :www
+}
+```
+___
 
 ```ruby
-MultiSync.run do
-
-  source :build, {
-    type: :local, # :local is the source's type, current options are :local, :manifest
-    source_dir: '/path_to_your_build_folder',
-    targets: [:assets] # an array of target names that this source should sync against
-  }
-
-  target :assets, {
-    type: :aws, # :aws is the target's type, current options are :aws
-    target_dir: 'your_aws_bucket',
-    destination_dir: 'an_optional_directory_inside_your_aws_bucket',
-    credentials: {
-      region: 'us-east-1',
-      aws_access_key_id: 'super_secret',
-      aws_secret_access_key: 'super_secret'
-    }
-  }
+# A source named ':image_assets' which will use a Sprockets ':manifest'
+# within '../public/assets' including only 'jpg, gif, png' files
+# which sets `cache_control` and `expires` headers and
+# synchronises with the target `:images`
+source :image_assets, {
+  type: :manifest,
+  source_dir: '../public/assets',
+  include: '*.{jpg,gif,png}',
+  resource_options: {
+    cache_control: 'public, max-age=31557600',
+    expires: CGI.rfc1123_date(Time.now + 31557600)
+  },
+  targets: :images
+}
+```
 
-end
+### Target
+
+```ruby
+...
 ```
 
+
+## Supported Libraries
+
+- [Rails](https://github.com/karlfreeman/multi_sync/wiki/rails)
+- Sinatra (WIP)
+- Middleman (WIP)
+- Jekyll (WIP)
+- Nanoc (WIP)
+- [POR](https://github.com/karlfreeman/multi_sync/wiki/por)
+- Rake (WIP)
+
 ## Badges
 
 [![Gem Version](http://img.shields.io/gem/v/multi_sync.svg)][gem]
@@ -110,8 +154,8 @@ end
 Behind the scenes we're using [Fog::Storage](http://fog.io/storage) which allows us to support the most popular storage providers
 
 - [Amazon S3](http://aws.amazon.com/s3)
-- [Rackspace CloudFiles](http://www.rackspace.com/cloud/files)
-- [Google Cloud Storage](https://developers.google.com/storage)
+- [Rackspace CloudFiles](http://www.rackspace.com/cloud/files) (WIP)
+- [Google Cloud Storage](https://developers.google.com/storage) (WIP)
 
 ## Supported Ruby Versions
 

data/lib/multi_sync/attributes/pathname.rb

@@ -0,0 +1,12 @@
+require 'virtus'
+require 'pathname'
+
+module MultiSync
+  module Attributes
+    class Pathname < ::Virtus::Attribute
+      def coerce(value)
+        ::Pathname.new(value)
+      end
+    end
+  end
+end

data/lib/multi_sync/client.rb

@@ -2,32 +2,32 @@ require 'set'
 require 'virtus'
 require 'lazily'
 require 'celluloid'
-require 'multi_sync/sources/local_source'
-require 'multi_sync/sources/manifest_source'
-require 'multi_sync/targets/aws_target'
-require 'multi_sync/targets/local_target'
+%w(sources targets).each do |dir|
+  Dir.glob(File.expand_path("../#{dir}/**/*.rb", __FILE__), &method(:require))
+end
 require 'multi_sync/mixins/pluralize_helper'
 
 module MultiSync
   class Client
-    include Virtus
+    include Virtus.model
     include MultiSync::Mixins::PluralizeHelper
 
-    attribute :supervisor
+    attribute :supervisor, Celluloid::SupervisionGroup
     attribute :incomplete_jobs, Set, default: Set.new
     attribute :running_jobs, Set, default: Set.new
     attribute :complete_jobs, Set, default: Set.new
     attribute :sources, Array, default: []
     attribute :sync_attempts, Integer, default: 0
     attribute :file_sync_attempts, Integer, default: 0
-    attribute :started_at, Time
-    attribute :finished_at, Time
+    attribute :started_at, Time, required: false
+    attribute :finished_at, Time, required: false
 
     # Initialize a new Client object
     #
     # @param options [Hash]
-    def initialize(options = {})
+    def initialize(*args)
       self.supervisor = Celluloid::SupervisionGroup.run!
+      super
     end
 
     def add_target(name, options = {})
@@ -50,12 +50,8 @@ module MultiSync
     alias_method :source, :add_source
 
     def synchronize
-      if sync_pointless?
-        MultiSync.debug "Preventing synchronization as there are #{sources.length} sources to sync..."
-        return
-      else
-        MultiSync.debug 'Starting synchronization...'
-      end
+      MultiSync.debug 'Preventing synchronization as there are no sources found.' && return if sync_pointless?
+      MultiSync.debug 'Starting synchronization...'
 
       determine_sync if first_run?
       sync_attempted
@@ -69,8 +65,9 @@ module MultiSync
       running_jobs.delete_if do | job |
         begin
           completed_job = { id: job[:id], response: job[:future].value, method: job[:method] }
-        rescue
+        rescue => error
           self.file_sync_attempts = file_sync_attempts + 1
+          MultiSync.warn error.inspect
           false
         else
           complete_jobs << completed_job
@@ -84,18 +81,23 @@ module MultiSync
     alias_method :sync, :synchronize
 
     def finalize
-      # if finished_at
-      #   elapsed = finished_at.to_f - started_at.to_f
-      #   minutes, seconds = elapsed.divmod 60.0
-      #   kilobytes = get_total_file_size_from_complete_jobs / 1024.0
-      #   MultiSync.debug "Sync completed in #{pluralize(minutes.round, 'minute')} and #{pluralize(seconds.round, 'second')}"
-      #   MultiSync.debug "#{pluralize(complete_jobs.length, 'file')} were synchronised (#{pluralize(get_complete_deleted_jobs.length, 'deleted file')} and #{pluralize(get_complete_upload_jobs.length, 'uploaded file')}) from #{pluralize(sources.length, 'source')} to #{pluralize(supervisor.actors.length, 'target')}"
-      #   MultiSync.debug "The upload weight totalled %.#{0}f #{pluralize(kilobytes, 'KB', 'KB', false)}" % kilobytes
-      #   MultiSync.debug "#{pluralize(file_sync_attempts, 'failed request')} were detected and re-tried"
-      # else
-      #   MultiSync.debug "Sync failed to complete with #{pluralize(incomplete_jobs.length, 'outstanding file')} to be synchronised"
-      #   MultiSync.debug "#{pluralize(complete_jobs.length, 'file')} were synchronised (#{pluralize(get_complete_deleted_jobs.length, 'deleted file')} and #{pluralize(get_complete_upload_jobs.length, 'uploaded file')}) from #{pluralize(sources.length, 'source')} to #{pluralize(supervisor.actors.length, 'target')}"
-      # end
+      if finished_at
+        elapsed = finished_at.to_f - started_at.to_f
+        minutes, seconds = elapsed.divmod 60.0
+        bytes = get_total_file_size_from_complete_jobs
+        MultiSync.debug "Sync completed in #{pluralize(minutes.round, 'minute')} and #{pluralize(seconds.round, 'second')}"
+        MultiSync.debug "#{pluralize(complete_jobs.length, 'file')} were synchronised (#{pluralize(get_complete_deleted_jobs.length, 'deleted file')} and #{pluralize(get_complete_upload_jobs.length, 'uploaded file')}) from #{pluralize(sources.length, 'source')} to #{pluralize(supervisor.actors.length, 'target')}"
+        if bytes > 1024.0
+          kilobytes = bytes / 1024.0
+          MultiSync.debug "The upload weight totalled %.#{0}f #{pluralize(kilobytes, 'kilobyte', nil, false)}" % kilobytes
+        else
+          MultiSync.debug "The upload weight totalled %.#{0}f #{pluralize(bytes, 'byte', nil, false)}" % bytes
+        end
+        MultiSync.debug "#{pluralize(file_sync_attempts, 'failed request')} were detected and re-tried"
+      else
+        MultiSync.debug "Sync failed to complete with #{pluralize(incomplete_jobs.length, 'outstanding file')} to be synchronised"
+        MultiSync.debug "#{pluralize(complete_jobs.length, 'file')} were synchronised (#{pluralize(get_complete_deleted_jobs.length, 'deleted file')} and #{pluralize(get_complete_upload_jobs.length, 'uploaded file')}) from #{pluralize(sources.length, 'source')} to #{pluralize(supervisor.actors.length, 'target')}"
+      end
 
       supervisor.finalize
     end
@@ -112,12 +114,8 @@ module MultiSync
     def get_total_file_size_from_complete_jobs
       total_file_size = 0
       get_complete_upload_jobs.each do | job |
-        # MultiSync.info job[:response]
-        # MultiSync.info job[:response].determine_content_length
-        if job[:response].content_length
-          total_file_size += job[:response].content_length
-        end
-
+        job_content_length = job[:response].content_length || job[:response].determine_content_length || 0
+        total_file_size += job_content_length
       end
       total_file_size
     end
@@ -164,8 +162,8 @@ module MultiSync
           abandoned_files_msg += ", however we're skipping them as :delete_abandoned_files is false" unless MultiSync.delete_abandoned_files
           MultiSync.debug abandoned_files_msg
 
-          # remove missing_files from source_files ( as we know they are missing so don't need to check them )
-          # remove abandoned_files from target_files ( as we know they are abandoned so don't need to check them )
+          # remove missing_files from source_files (as we know they are missing so don't need to check them)
+          # remove abandoned_files from target_files (as we know they are abandoned so don't need to check them)
           outdated_files.concat determine_outdated_files(source_files - missing_files, target_files - abandoned_files)
           MultiSync.debug "#{outdated_files.length} of the files are outdated"
 

data/lib/multi_sync/configuration.rb

@@ -4,7 +4,7 @@ require 'celluloid'
 
 module MultiSync
   class Configuration
-    include Virtus
+    include Virtus.model
 
     attribute :verbose, Boolean, default: false
     attribute :force, Boolean, default: false
@@ -18,11 +18,9 @@ module MultiSync
     # Initialize a new Configuration object
     #
     # @param options [Hash]
-    def initialize(options = {})
+    def initialize(*args)
       Celluloid.logger = MultiSync.test? ? nil : MultiSync.logger
-      options.each_pair do |key, value|
-        send("#{key}=", value) if attributes.keys.include?(key)
-      end
+      super
     end
 
     def celluloid_cores

data/lib/multi_sync/extensions/middleman.rb

@@ -1,7 +1,7 @@
 module MultiSync
   module Extensions
     class Middleman
-      MultiSync.info "Middleman -v #{::Middleman::VERSION} auto-detected"
+      MultiSync.debug "Middleman -v #{::Middleman::VERSION} auto-detected"
 
       class << self
         def source_dir

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

@@ -16,8 +16,6 @@ module MultiSync
 
         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
@@ -37,6 +35,8 @@ module MultiSync
 
           MultiSync.delete_abandoned_files = asset_sync_yml['existing_remote_files'] == 'delete'
           MultiSync.run_on_build = asset_sync_yml['run_on_precompile']
+
+          MultiSync.info 'AssetSync YAML file found, migrating options...' if MultiSync.run_on_build
         end
       end
     end

data/lib/multi_sync/extensions/rails.rb

@@ -4,7 +4,7 @@ module MultiSync
     require 'multi_sync/extensions/rails/asset_sync'
 
     class Rails
-      MultiSync.info "Rails -v #{::Rails::VERSION::STRING} auto-detected"
+      MultiSync.debug "Rails -v #{::Rails::VERSION::STRING} auto-detected"
 
       class << self
         def source_dir

data/lib/multi_sync/logging.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'thread'
 
 module MultiSync
   module Logging
@@ -31,9 +32,8 @@ module MultiSync
     end
 
     def log(message, level = :debug)
-      # We're in verbose mode so disable all non-info logs
+      # We're not in verbose mode so disable all non-info logs
       return if !MultiSync.verbose && level != :info
-
       MUTEX.synchronize do
         logger.send(level, message)
       end

data/lib/multi_sync/resource.rb

@@ -5,63 +5,46 @@ require 'multi_sync/mixins/log_helper'
 
 module MultiSync
   class Resource
-    include Virtus
     include Comparable
+    include Virtus.model
     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
+    attribute :etag, String, default: :determine_etag, lazy: true
+    attribute :mtime, Time, default: :determine_mtime, lazy: true
+    attribute :content_length, Numeric, default: :determine_content_length, lazy: true
+    attribute :content_type, String, default: :determine_content_type, lazy: true
+    attribute :digest, String, default: ''
 
     AWS_ATTRIBUTES = [{
       name: :storage_class,
       type: String,
-      default_value: 'STANDARD'
+      default: 'STANDARD'
     }, {
       name: :acl,
       type: String,
-      default_value: 'public-read'
+      default: 'public-read'
     }, {
       name: :expires,
       type: String,
-      default_value: nil
+      required: false
     }, {
       name: :cache_control,
       type: String,
-      default_value: nil
+      required: false
     }, {
       name: :encryption,
       type: String,
-      default_value: nil
+      required: false
     }]
 
     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
+      def_attribute_hash = {}
+      def_attribute_hash[:default] = attribute_hash[:default] unless attribute_hash[:default].nil?
+      def_attribute_hash[:required] = attribute_hash[:required] unless attribute_hash[:required].nil?
+      send(:attribute, attribute_hash[:name], attribute_hash[:type], def_attribute_hash)
     end
 
     def hash

data/lib/multi_sync/resources/local_resource.rb

@@ -3,6 +3,7 @@ require 'multi_sync/resource'
 
 module MultiSync
   class LocalResource < Resource
+
     def body
       File.read(path_with_root.to_s)
     rescue

data/lib/multi_sync/resources/remote_resource.rb

@@ -2,10 +2,7 @@ require 'multi_sync/resource'
 
 module MultiSync
   class RemoteResource < Resource
-    def initialize(options = {})
-      self.file = options.fetch(:file, nil)
-      super(options)
-    end
+    attribute :file
 
     def body
       file.body

data/lib/multi_sync/source.rb

@@ -1,40 +1,28 @@
 require 'virtus'
 require 'pathname'
 require 'lazily'
+require 'multi_sync/attributes/pathname'
 require 'multi_sync/mixins/log_helper'
+require 'multi_sync/resources/local_resource'
 
 module MultiSync
   class Source
-    include Virtus
+    include Virtus.model
     include MultiSync::Mixins::LogHelper
 
-    attribute :targets, Array, default: []
-    attribute :source_dir, String
-    attribute :source_options, Hash
-    attribute :include, String
-    attribute :exclude, String
+    attribute :source_dir, MultiSync::Attributes::Pathname
 
-    # 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
+    attribute :targets, Array, default: []
+    attribute :resource_options, Hash, default: {}
+    attribute :include, String, default: '**/*'
+    attribute :exclude, String, default: ''
 
     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))
+      path_options = { path_with_root: pathname, path_without_root: pathname.relative_path_from(source_dir).cleanpath }
+      MultiSync::LocalResource.new(path_options.merge(options).merge(resource_options))
     end
   end
 end

data/lib/multi_sync/sources/manifest_source.rb

@@ -22,7 +22,7 @@ module MultiSync
       # 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 || '')
+        next if !path.fnmatch?(include.to_s) || path.fnmatch?(exclude.to_s || '')
         file = path_to_local_resource(path, mtime: value['mtime'], digest: value['digest'], content_length: value['size'])
         files << file
       }
@@ -33,7 +33,7 @@ module MultiSync
     private
 
     def locate_manifest(dir)
-      Dir.glob(dir.to_s + 'manifest*.{json,yaml,yml}').max { |f| File.ctime(f) }
+      Dir.glob(dir + 'manifest*.{json,yaml,yml}').max { |f| File.ctime(f) }
     end
 
     def parse_manifest(manifest_path)