dropboximus_prime 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 034be9bebd56a383e503de2785a307857edb77bd
-  data.tar.gz: c24f1e176e2fd5d8d66ab445b1100a8209c52379
+  metadata.gz: 373d813b947c72c161f5e7aa35dc49c90792adb6
+  data.tar.gz: 1b438d41dd8bc92b2cf83ab2a28861e9baca66c5
 SHA512:
-  metadata.gz: 471f56380be4cfd1025f84b2ce548ae0a64639ffddde1a42bf7079edddfba34319350b168d553ed7607919336f32fc488f8740d6825d89554fbbc5a55a61581e
-  data.tar.gz: 9c649d9b97b8a22fc7a26a637a9d3f267867dd5827ff6ba282a821140e9fb23fd10772e3ea401f01fe06db334f95ca4baa3abc990b932f0f30fab9f985213221
+  metadata.gz: 2c0ef5a55b11611cded0a493416b13e3d1ecf4212fe1ddb44cb9325891978369fff2e42d6e2522526418336d36c0ff90699b27cb993550b68c4e0f17bae6d5f4
+  data.tar.gz: a74983230dc7989e099eeac90ff5bb8f7faa726bdca5702bb3ff0df9c2a69f9208baf0028348d448ab814003a2dafab8ba498acc09ea75e47ae38af86610b30e

data/lib/dropboximus_prime.rb

@@ -1,180 +1,287 @@
-require 'delegate'
 require 'yaml'
 require 'dropbox_sdk'
 require 'redcarpet'
 require 'guid'
 require 'pathname'
 require 'fileutils'
+require 'time'
 
 class DropboximusPrime
-  attr_accessor :settings
+  attr_accessor :settings, :markdown, :dropbox
 
-  def initialize settings=false
-    @settings = !settings ? YAML.load_file('config/dropboximus_prime_settings.yml') : settings
-    @dropbox = DropboxClient.new(@settings['dropbox']['access_token'])
-    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, autolink: true, tables: true)
+  def initialize arg=nil
+    @settings = init_settings(arg)
+    @dropbox = init_dropbox
+    @markdown = init_markdown
   end
 
   def get *items
-    gotten = []
-    items.each { |item| gotten << get_item(item) }
-    gotten.length == 1 ? gotten.first : gotten
+    aggregate_paths(items).each_with_object({}) { |key, memo|
+      memo[key] = get_item(cache_path(key))
+    }
   end
 
-  def get_item simple_path
-    filepath = proper_path(simple_path)
-
-    return false unless File.exist?(filepath)
+  def get_one item
+    get(item).values[0]
+  end
 
-    item = File.read(filepath)
+  def refresh *items
+    if items.length > 0
+      local_paths = aggregate_paths(items)
+    else
+      local_paths = dropbox_list_files_recursively(@settings['dropbox']['path']).map! { |item|
+        remote_path_to_relative_path item
+      }
+    end
 
-    return YAML.load(item) if is_yaml?(filepath)
-    return @markdown.render(item) if is_markdown?(filepath)
-    return image_info(simple_path) if is_image?(filepath)
-    item
+    local_paths.each { |item|
+      refresh_item(item)
+    }
   end
 
-  def refresh! *items
-    items = dropbox_lsr_f(@settings['dropbox']['path']) unless items.length > 0
-    items.each { |i| refresh_item!(dropbox_path_to_simple_path(i), @settings['cache']['timeout']) }
+  def prune!
+    local_files = aggregate_paths(['**/*'])
+    local_dirs = dirs_only(local_files)
+
+    remote_files = dropbox_list_files_recursively(@settings['dropbox']['path']).each_with_object([]) { |x, memo|
+      memo.push remote_path_to_relative_path(x)
+    }
+    remote_dirs = dropbox_list_dirs_recursively(@settings['dropbox']['path']).each_with_object([]) { |x, memo|
+      memo.push remote_path_to_relative_path(x)
+    }
+
+    orphan_files = local_files.each_with_object([]) { |x, memo|
+      memo.push x unless remote_files.include? x
+    }
+    orphan_dirs = local_dirs.each_with_object([]) { |x, memo|
+      memo.push x unless remote_dirs.include? x
+    }
+
+    orphan_files.each { |x|
+      FileUtils.rm(cache_path(x), force: true)
+    }
+    orphan_dirs.each { |x|
+      FileUtils.rm(cache_path(x), force: true)
+    }
   end
 
-  def refresh_item! simple_path, cache_timeout=nil
-    filename = Pathname.new(simple_path).basename.to_s
-    local_filepath = proper_path(simple_path)
-    local_path = local_filepath.sub('/' + filename,'')
-    dropbox_filepath = dropbox_path(simple_path)
-    tmp_filepath = make_tmp_path
+  private
 
-    return false unless item_stale?(local_filepath, cache_timeout)
-    return false unless dropbox_file_exists?(dropbox_filepath)
+    def aggregate_paths items
+      items.flatten.each_with_object([]) { |x, memo|
+        Dir.glob(cache_path(x)).each { |y|
+          memo.push relative_path(y) if File.file?(y) && !is_thumbnail?(y)
+        }
+      }
+    end
 
-    store(dropbox_filepath, local_filepath, local_path, tmp_filepath)
+    def get_item path
+      return YAML.load_file(path) if is_yaml?(path)
+      return @markdown.render(File.read(path)) if is_markdown?(path)
+      return imagify(path) if is_image?(path)
+    end
 
-    if is_image? filename
-      dropbox_thumbnail_sizes.each { |size| store_thumbnail(dropbox_filepath, local_filepath, local_path, tmp_filepath, size) }
+    DPImage = Struct.new(:url, :title, :alt, :thumbnail_s_url, :thumbnail_m_url, :thumbnail_l_url, :thumbnail_xl_url)
+    def imagify relative_path
+      url = public_path(relative_path)
+
+      meta = get_image_meta(relative_path)
+      alt = meta[0]
+      title = meta[1]
+
+      thumbnail_s_url = imagify_suffix url, '_s'
+      thumbnail_m_url = imagify_suffix url, '_m'
+      thumbnail_l_url = imagify_suffix url, '_l'
+      thumbnail_xl_url = imagify_suffix url, '_xl'
+
+      DPImage.new(url,title,alt,thumbnail_s_url,thumbnail_m_url,thumbnail_l_url,thumbnail_xl_url)
     end
-  end
 
-  private
+    def imagify_suffix path, suffix
+      File.join(File.dirname(path), insert_into_filename_before_extension(File.basename(path), suffix))
+    end
+
+    def get_image_meta relative_path
+      begin
+        cache_path = cache_path(relative_path)
+        meta_file_path = File.join(File.dirname(cache_path), '_'+File.basename(cache_path,".*")+'.yml')
+        meta = YAML.load_file(meta_file_path)
+        [
+          meta['alt'],
+          meta['title']
+        ]
+      rescue
+        [
+          '',
+          ''
+        ]
+      end
+    end
 
-    def store(dropbox_filepath, local_filepath, local_path, tmp_filepath)
-      File.open(tmp_filepath, 'w') { |file| file.write(@dropbox.get_file(dropbox_filepath)) }
-      FileUtils::mkdir_p local_path unless File.directory? local_path
-      FileUtils.mv tmp_filepath, local_filepath
+    def cache_path relative_path
+      File.join(@settings['cache']['path'], relative_path)
     end
 
-    def store_thumbnail(dropbox_filepath, local_filepath, local_path, tmp_filepath, size)
-      extension = File.extname(local_filepath)
-      File.open(tmp_filepath, 'w') { |file| file.write(@dropbox.thumbnail(dropbox_filepath, size)) }
-      FileUtils::mkdir_p local_path unless File.directory? local_path
-      FileUtils.mv tmp_filepath, local_filepath.sub(extension, '_' + size + extension)
+    def relative_path cache_path
+      new_path = cache_path.sub(@settings['cache']['path'], '')
+      new_path[0] = '' if new_path[0] == '/'
+      new_path
     end
 
-    def dropbox_path simple_path
-      simple_path = strip_initial_path(simple_path)
-      @settings['dropbox']['path'] + '/' + simple_path
+    def remote_path relative_path
+      File.join(@settings['dropbox']['path'], relative_path)
     end
 
-    def dropbox_path_to_simple_path dropbox_path
-      dropbox_path.downcase.sub(@settings['dropbox']['path'].downcase + '/', '')
+    def remote_path_to_relative_path remote_path
+      new_path = remote_path.sub(@settings['dropbox']['path'], '')
+      new_path[0] = '' if new_path[0] == '/'
+      new_path
     end
 
-    def dropbox_lsr(root_path, list=[])
-      @dropbox.metadata(root_path)['contents'].each { |obj|
-        dropbox_lsr(obj['path'], list) if obj['is_dir']
-        list << obj
-      }
-      list
+    def public_path relative_path
+      File.join(@settings['cache']['http_prefix'], relative_path)
     end
 
-    def dropbox_lsr_d root_path
-      list = []
-      dropbox_lsr(root_path).each { |item| list << item['path'].downcase if item['is_dir'] == true }
-      list
+    def insert_into_filename_before_extension(filename, insert)
+      extension = File.extname(filename)
+      filename.reverse.sub(extension.reverse, (insert + extension).reverse).reverse
     end
 
-    def dropbox_lsr_f root_path
-      list = []
-      dropbox_lsr(root_path).each { |item| list << item['path'].downcase if item['is_dir'] == false }
-      list
+    def dirs_only(paths)
+      paths.each_with_object([]) { |x, memo|
+        memo.push File.dirname(x)
+        memo.delete('.')
+      }.uniq
+    end
+
+    def rev_path relative_path
+      File.join(@settings['rev_cache']['path'], relative_path)
+    end
+
+    def set_rev relative_path, rev
+      rev_path = rev_path(relative_path)
+      rev_dir = File.dirname(rev_path)
+      FileUtils::mkdir_p(rev_dir) unless File.directory?(rev_dir)
+      File.open(rev_path, 'w') { |file| file.write(rev) }
     end
 
-    def dropbox_file_exists? path
+    def unset_rev relative_path
+      rev_path = rev_path(relative_path)
+      File.delete(rev_path)
+    end
+
+    def get_rev relative_path
       begin
-        meta = @dropbox.metadata path
-        !meta['is_deleted'] && !meta['is_dir']
+        File.read(rev_path(relative_path))
       rescue
+        return nil
       end
     end
 
-    def strip_initial_path simple_path
-      simple_path = simple_path.sub('/','') if simple_path[0,1] == '/'
-      simple_path = simple_path.sub('./','') if simple_path[0,2] == './'
-      simple_path
+    def is_image? filename
+      ['.jpg', '.gif', '.png', '.bmp'].any? { |word| filename.end_with?(word) }
     end
 
-    def private_path simple_path
-      simple_path = strip_initial_path(simple_path)
-      @settings['cache']['path'] + '/' + simple_path
+    def is_markdown? filename
+      ['.md','.markdown'].any? { |word| filename.end_with?(word) }
     end
 
-    def public_path simple_path
-      simple_path = strip_initial_path(simple_path)
-      @settings['cache']['public_path'] + '/' + simple_path
+    def is_yaml? filename
+      ['.yml','.yaml'].any? { |word| filename.end_with?(word) }
     end
 
-    def proper_path simple_path
-      public_file?(simple_path) ? public_path(simple_path) : private_path(simple_path)
+    def is_thumbnail? path
+      thumbnail_suffixes.any? { |word| File.basename(path, ".*").end_with?(word) }
     end
 
-    def make_tmp_path
-      @settings['cache']['tmp_path'] + '/' + Guid.new.to_s
+    def init_markdown
+      Redcarpet::Markdown.new(Redcarpet::Render::HTML, autolink: true, tables: true)
     end
 
-    def dropbox_thumbnail_sizes
-      ['s', 'm', 'l', 'xl']
+    def init_dropbox
+      DropboxClient.new(@settings['dropbox']['access_token'])
     end
 
-    def public_file? filepath
-      Pathname.new(filepath).basename.to_s.index('_') != 0
+    def dropbox_list_recursively(root_path, list=[])
+      @dropbox.metadata(root_path)['contents'].each { |obj|
+        dropbox_list_recursively(obj['path'], list) if obj['is_dir']
+        list << obj
+      }
+      list
     end
 
-    def is_image? filename
-      ['.jpg', '.gif', '.png', '.bmp'].any? { |word| filename.include?(word) }
+    def dropbox_list_dirs_recursively(root_path, list=[])
+      dropbox_list_recursively(root_path).each { |item| list << item['path'].downcase if item['is_dir'] == true }
+      list
     end
 
-    def is_markdown? filename
-      ['.md','.markdown'].any? { |word| filename.include?(word) }
+    def dropbox_list_files_recursively(root_path, list=[])
+      dropbox_list_recursively(root_path).each { |item| list << item['path'].downcase if item['is_dir'] == false }
+      list
     end
 
-    def is_yaml? filename
-      ['.yml','.yaml'].any? { |word| filename.include?(word) }
+    def refresh_item relative_path
+      begin
+        meta = @dropbox.metadata(remote_path(relative_path))
+      rescue
+        return false
+      end
+
+      remote_path = remote_path(relative_path)
+      last_rev = get_rev(relative_path)
+      current_rev = meta['rev']
+      return relative_path if last_rev == current_rev
+
+      dropbox_get(remote_path, current_rev)
+      dropbox_get_thumbnails(remote_path) if is_image?(File.basename(remote_path))
+      relative_path
     end
 
-    def item_stale? filepath, cache_timeout=nil
-      return true unless File.exist? filepath
-      cache_timeout ||= @settings['cache']['timeout']
-      (Time.now - File.stat(filepath).mtime).to_i > cache_timeout
+    def dropbox_get remote_path, rev=nil
+      relative_path = remote_path_to_relative_path(remote_path)
+      cache_path = cache_path(relative_path)
+      cache_dir = File.dirname(cache_path)
+      rev_path = rev_path(relative_path)
+      tmp_path = make_tmp_path
+
+      File.open(tmp_path, 'w') { |file| file.write(@dropbox.get_file(remote_path)) }
+      FileUtils::mkdir_p(cache_dir) unless File.directory?(cache_dir)
+      FileUtils.mv tmp_path, cache_path
+      set_rev relative_path, rev if rev
     end
 
-    def image_info simple_path
-      p_path = @settings['cache']['public_prefix'] + simple_path
-      
-      {
-        'public_path' => p_path,
-        'thumbnails' => {
-          's' => insert_into_filename_before_extension(p_path, '_s'),
-          'm' => insert_into_filename_before_extension(p_path, '_m'),
-          'l' => insert_into_filename_before_extension(p_path, '_l'),
-          'xl' => insert_into_filename_before_extension(p_path, '_xl')
-        }
+    def thumbnail_sizes
+      ['s','m','l','xl']
+    end
+
+    def thumbnail_suffixes
+      thumbnail_sizes.each_with_object([]) { |x, memo|
+        memo.push '_'+x
       }
     end
 
-    def insert_into_filename_before_extension(filename, insert)
-      extension = File.extname(filename)
-      filename.reverse.sub(extension.reverse, (insert + extension).reverse).reverse
+    def dropbox_get_thumbnails(remote_path)
+      relative_path = remote_path_to_relative_path(remote_path)
+      cache_path = cache_path(relative_path)
+      tmp_path = make_tmp_path
+
+      return false unless is_image?(relative_path)
+
+      thumbnail_sizes.each { |size|
+        suffix = '_'+size
+        File.open(tmp_path, 'w') { |file| file.write(@dropbox.thumbnail(remote_path, size)) }
+        FileUtils.mv tmp_path, File.join(File.dirname(cache_path), insert_into_filename_before_extension(File.basename(cache_path), suffix))
+      }
+    end
+
+    def make_tmp_path
+      File.join(@settings['tmp_cache']['path'], Guid.new.to_s)
+    end
+
+    def init_settings arg
+      return YAML.load_file('config/dropboximus_prime.yml') if !arg
+      return YAML.load_file(arg) if arg.is_a? String
+      return arg if arg.is_a? Hash
     end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dropboximus_prime
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 platform: ruby
 authors:
 - Ryan Burnette
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dropbox-sdk