tumblr_draftking 0.7.0.4

data/lib/draftking/patches/tumblr_client.rb

@@ -0,0 +1,10 @@
+module Tumblr
+  # Tumblr::Blog patch
+  module Blog
+    # Patch for a bug in the tumblr_client 0.8.5 gem
+    def draft(blog_name, options = {})
+      validate_options([:limit, :before_id], options)
+      get(blog_path(blog_name, 'posts/draft'), options)
+    end
+  end
+end

data/lib/draftking/posts/post.rb

@@ -0,0 +1,150 @@
+require_relative 'posts_helpers'
+include DK::Posts
+
+module DK
+  # Tumblr Post
+  class Post
+    attr_accessor :id, :state, :tags, :comment, :summary, :reblog_key
+    attr_accessor :keep_tree, :changed, :saved, :blog_url
+    attr_accessor :image
+    attr_reader   :data
+
+    # @param hash [Hash] Post Data
+    # @param keep_tree [Bool] Attach Reblog Tree?
+    def initialize(hash, keep_tree: nil)
+      return if hash.nil?
+      @data       = JSON.parse(hash.to_json, object_class: OpenStruct)
+      @id         = @data.id # hash['id']
+      @state      = process_state(@data.state) # hash['state'])
+      @tags       = @data.tags # hash['tags']
+      @comment    = @data.reblog.comment # hash['reblog']['comment']
+      @summary    = @data.summary # hash['summary']
+      @blog_url   = tumblr_url(@data.blog_name) # hash['blog_name'])
+      @reblog_key = @data.reblog_key # hash['reblog_key']
+      @image      = begin
+                      @data.photos.first.original_size.url
+                    rescue
+                      nil
+                    end
+      @keep_tree  = keep_tree.nil? ? false : keep_tree
+      @changed    = false
+      @saved      = 0
+    end
+
+    # String of post data
+    def to_s
+      "id = #{@id}\n" \
+        "state = #{@state}\n" \
+        "tags = #{@tags}\n" \
+        "comment = #{@comment}\n" \
+        "summary = #{@summary}\n" \
+        "blog_url = #{@blog_url}\n" \
+        "reblog_key = #{@reblog_key}\n" \
+        "keep_tree = #{@keep_tree}\n" \
+        "changed = #{@changed}\n"
+    end
+
+    # Change the state of a post
+    # @param state [String] New State
+    def change_state(state)
+      return false unless VALID_STATE.include?(state)
+      return false if @state == state
+      @state = state
+      @changed = true
+    end
+
+    # Add a comment to a post
+    # @param comment [String] New Comment
+    def replace_comment_with(comment)
+      return false if comment.nil? || @comment.include?(comment)
+      @comment = comment
+      @changed = true
+    end
+
+    # Check if a post needs to be modified
+    # @param key_text [String] key_text
+    def has_key_text?(key_text)
+      return true if key_text.nil?
+      @comment.include?(key_text)
+    end
+
+    # Delete a Post
+    # @param client [Tumblr::Client] Instance of Tumblr Client
+    # @param simulate [Bool] Simulate Action?
+    def delete(client:, simulate: nil)
+      return 1 if simulate
+      res = client.delete @blog_url, @id
+      @changed = true if res['id']
+      res['id'] ? 1 : 0
+    end
+
+    # Reblog a Post
+    # @param client [Tumblr::Client] Instance of Tumblr Client
+    # @param simulate [Bool] Simulate Action?
+    def reblog(client:, simulate: nil)
+      return 1 if simulate
+      client.reblog @blog_url,
+                    id: @id,
+                    reblog_key: @reblog_key,
+                    comment: @comment
+    end
+
+    # Save a post
+    # @param client [Tumblr::Client] Instance of Tumblr Client
+    # @param simulate [Bool] Simulate Action?
+    def save(client:, simulate: nil)
+      return 0 unless @changed
+      return @saved = 1 if simulate
+      res = client.edit @blog_url,
+                        id:                 @id,
+                        reblog_key:         @reblog_key,
+                        state:              @state,
+                        attach_reblog_tree: @keep_tree,
+                        tags:               @tags.join(','),
+                        caption:            @comment
+      return 0 unless res && res['id']
+      @changed = false
+      @saved   = 1
+    end
+
+    # Generate post tags from post comment
+    # @param keep_tags [Bool] Preserve Existing Tags?
+    # @param add_tags [String] New tags
+    # @param exclude [String] Tags to exclude
+    # @param credit [Bool] Give draftking a tag credit
+    def generate_tags(keep_tags: nil, add_tags: nil, exclude: nil, credit: false)
+      tags  = comment_to_tags(@comment)
+      tags += csv_to_a(add_tags)    if add_tags
+      tags += @tags                 if keep_tags
+      tags << DK::CREDIT_TAG        if credit
+      tags -= csv_to_a(exclude)     if exclude
+      @changed = true unless @tags.sort.uniq == tags.sort.uniq
+      @tags = tags
+    end
+
+    # Remove existing Post tags
+    def clear_tags
+      @changed = true unless @tags.empty?
+      @tags = []
+    end
+
+    private
+
+    def process_state(state)
+      return DK::DRAFT unless state
+      return DK::QUEUE if state == 'queued'
+      state
+    end
+
+    def comment_to_tags(comment)
+      comment.gsub(HTML_TAG_PATTERN, '') # Remove HTML Tags
+             .gsub(%r{[\/\\|]}, ',')     # Convert Separators
+             .gsub(' , ', ',')           # Clean up tags
+             .split(',')                 # Return array
+    end
+
+    def csv_to_a(csv)
+      csv.split(',')
+    end
+  end
+end

data/lib/draftking/posts/posts_helpers.rb

@@ -0,0 +1,55 @@
+module DK
+  # Helper Methods
+  module Posts
+    # Display progress percentage
+    # @param current [Int] Progress Counter
+    # @param total [Int] # Items to be processed
+    # @param message [String] Display message for process
+    # @param done [Bool] Processing Complete?
+    # @param modified [Int] # of items modified
+    def show_progress(current: 0, total: 0, message: '', done: false, modified: 0)
+      indicator, newline, progress = setup_done(modified) if done
+      indicator, newline, progress = setup_undone(current, total) unless done
+      print "#{indicator}#{message}#{progress}#{' ' * 30}\r#{newline}"
+      $stdout.flush unless done
+    end
+
+    # Values for displaying completed process
+    def setup_done(modified)
+      indicator  = '√ '
+      newline    = "\n"
+      progress   = "(#{modified} modified)"
+      [indicator, newline, progress]
+    end
+
+    # Values for displaying in-progress process
+    def setup_undone(current, total)
+      tildes = current.to_i % 4
+      indicator  = "~#{'~' * tildes}#{' ' * (3 - tildes)}> "
+      newline    = nil
+      percentage = total > 0 ? ((current.to_f / total.to_f) * 100).round : 0
+      progress   = "#{current} / #{total} [#{percentage}\%] "
+      [indicator, newline, progress]
+    end
+
+    # Construct Tumblr URL string
+    # @param blog_name [String] Blog Name
+    def tumblr_url(blog_name)
+      blog_name += '.tumblr.com' unless blog_name.include?('.')
+      blog_name
+    end
+
+    # Convert source symbol to string
+    # @param symbol [Symbol] Source Symbol
+    def source_string(symbol)
+      return 'draft' unless symbol
+      symbol.to_s
+    end
+
+    # index < limit
+    def index_within_limit?(index, limit)
+      return true if limit.nil? || limit.zero?
+      index < limit
+    end
+  end
+end

data/lib/draftking/posts.rb

@@ -0,0 +1,173 @@
+require_relative 'posts/posts_helpers'
+require_relative 'posts/post'
+require 'thread'
+
+module DK
+  # Post operations common to queue/draft
+  module Posts
+    # Common code for Post operations
+    # @param options[:limit] [Int] Maximum number of posts to process
+    # @param options[:message] [String] Message to display during processing
+    # @param options[:shuffle] [Bool] Randomize order of posts
+    # @param options[:blog_name] [String] Name of blog to target
+    # @param options[:mute] [String] Suppress progress indicator
+    # @param options[:test_data] [[Hash]] Array of post hash data
+    # @param options[:simulate] [bool] Simulation?
+    # @return [int] Number of modified posts
+    def post_operation(options, &block)
+      work, total, results, reporter = setup_operation(options)
+      workers = (0...DK::MAX_THREADS).map { Thread.new { generate_worker(work, results, total, block) } }
+      workers.map(&:join)
+      mod_count, mod_posts = calculate_result(results)
+      show_progress(message: message, done: true, modified: mod_count) unless @mute
+      reporter.new(objects: mod_posts, title: REPORT_TITLE, fields: REPORT_FIELDS, simulate: @simulate).show unless @mute
+      act_on_blog(name: @blog_name) # Refresh account info
+      [mod_count, mod_posts]
+    end
+
+    # Work queue processor
+    def generate_worker(*data, block)
+      work, results, total = data
+      begin
+        while post = work.pop(true)
+          po = Post.new(post, keep_tree: @keep_tree)
+          block.call(po, results.size) # Do work on Post
+          po.save(client: @client, simulate: @simulate)
+          results.push(po)
+          show_progress(current: results.size, total: total, message: message) unless @mute
+        end
+      rescue ThreadError # Queue empty
+      end
+    end
+
+    # Common initialization for post operations
+    def setup_operation(options)
+      process_options(options)
+      act_on_blog(name: @blog_name)
+      posts = @shuffle ? get_posts.shuffle : get_posts
+      work = posts_to_queue(posts)
+      reporter = options[:reporter] || DK::Reporter
+      [work, work.size, Queue.new, reporter]
+    end
+
+    # Create queue of Posts for worker threads
+    def posts_to_queue(posts)
+      work_q = Queue.new
+      posts.each { |p| work_q.push(p) }
+      work_q
+    end
+
+    # Determine number of modified posts
+    def calculate_result(result_q)
+      mod_count = 0
+      mod_posts = []
+      return [mod_count, mod_posts] if result_q.empty?
+      while post = result_q.pop
+        mod_count += post.saved
+        mod_posts << post if post.saved > 0
+        break if result_q.empty?
+      end
+      [mod_count, mod_posts]
+    end
+
+    # Add a comment to Posts
+    # @param options[:credit] [Bool] Give dk credit?
+    # @param options[:comment] [string] String to add as comment
+    # @param options[:limit] [Int] Max number of modified posts
+    # @param options[:message] [String] Message to display during processing
+    # @param options[:source] [Symbol] Target posts from :draft or :queue
+    # @param options[:simulate] [bool] Simulation?
+    # @param options[:mute] [String] Suppress progress indicator
+    # @return [int] Number of modified posts
+    def comment_posts(options = {})
+      src = source_string(options[:source])
+      options[:message] = "Adding #{src} comment \'#{comment}\': "
+      mod_count, _mod_posts = post_operation(options) do |post, _|
+        post.replace_comment_with(@comment)
+        post.generate_tags(keep_tags: @keep_tags,
+                           add_tags:  @tags,
+                           exclude:   @comment,
+                           credit:    @credit) if @auto_tag
+      end
+      mod_count
+    end
+
+    # @param options[:credit] [Bool] Give dk credit?
+    # @param options[:source] [Symbol] Target posts from :draft or :queue
+    # @param options[:mute] [String] Suppress progress indicator
+    # @param options[:blog_name] [String] Name of blog to target
+    # @param options[:keep_tags] [bool] Preserve existing post tags
+    # @param options[:keep_tree] [bool] Preserve existing post comments
+    # @param options[:simulate] [bool] Simulation?
+    # @param options[:comment] [String] Exclude :comment from tags
+    # @return [int] Number of modified posts
+    def tag_posts(options)
+      src = source_string(options[:source])
+      options[:message] = "Tagging #{src} with #{options[:add_tags]}: "
+      mod_count, _mod_posts = post_operation(options) do |post, _|
+        post.generate_tags(keep_tags: @keep_tags,
+                           add_tags:  @tags,
+                           exclude:   @comment,
+                           credit:    @credit) if @auto_tag
+      end
+      mod_count
+    end
+
+    # Determine draft data to use.
+    # @param options[:test_data] [[Hash]] Array of post hash data
+    # @param options[:limit] [Int] Limit # of posts selected
+    # @param options[:blog_url] [string] URL of blog to read from
+    # @param options[:source] [Symbol] Get posts from :draft or :queue
+    # @param options[:before_id] [Int] [:draft] ID of post to begin reading from
+    # @param options[:offset] [Int] [:queue] Post index to start reading from
+    # @return [[Post]] Array of Post Hash data
+    def get_posts
+      return some_test_data if @test_data
+      return all_posts.uniq unless @limit
+      return some_posts(offset: @offset, before_id: @before_id) if @limit <= 50
+      limited_posts
+    end
+
+    # Get up to 50 Posts
+    # @param before_id [Int] [:draft] ID of post to begin reading from
+    # @param offset [Int] [:queue] Post index to start reading from
+    # @return [[Post]] Array of Post Hash data
+    def some_posts(before_id: 0, offset: 0)
+      options = { limit: [(@limit || 50), 50].min }
+      options[@source == :draft ? :before_id : :offset] = (@source == :draft ? before_id : offset)
+
+      result = @client.send(@source, @blog_url, options).first[1]
+      result.is_a?(Integer) ? [] : result
+    end
+
+    # Get @limit # of Posts
+    def limited_posts
+      result = []
+      until result.size >= @limit
+        chunk = some_posts(offset: @offset, before_id: @before_id)
+        break if chunk.empty?
+        result += chunk
+        @offset    = chunk.size
+        @before_id = chunk.last['id']
+      end
+      result.take(@limit)
+    end
+
+    # Collect all Posts
+    # @param last_id [Int] ID of post to begin reading from (for reading Drafts)
+    # @param offset [Int] Post index to start reading from (for reading Queue)
+    # @param blog_url [string] URL of blog to read from
+    # @param source [Symbol] Get posts from :draft or :queue
+    # @return [[Post]] Array of Post Hash data
+    def all_posts(last_id: 0, offset: 0)
+      chunk = some_posts(before_id: last_id, offset: offset)
+      return chunk if chunk.empty?
+      chunk + all_posts(last_id: chunk.last['id'], offset: offset + chunk.size)
+    end
+
+    # Handle limits for test data
+    def some_test_data
+      @limit ? @test_data.take(@limit) : @test_data
+    end
+  end
+end

data/lib/draftking/queue.rb

@@ -0,0 +1,17 @@
+module DK
+  #----------------------------- Queue Methods ----------------------------- #
+  module TQueue
+    # Move from Queue to Drafts
+    # @param options[:key_text] [String] Move posts not containing :key_text
+    # @return [Int] Number of modified posts
+    def move_to_drafts(options)
+      options[:message] = 'Moving Queue ~> Drafts: '
+      options[:shuffle] = false
+      options[:state]   = DK::DRAFT
+      mod_count, _mod_posts = post_operation(options) do |post, _|
+        post.changed = !post.has_key_text?(@key_text)
+      end
+      mod_count
+    end
+  end
+end

data/lib/draftking/reporter.rb

@@ -0,0 +1,62 @@
+require 'terminal-table'
+
+module DK
+  # Generate report of object data
+  class Reporter
+    attr_accessor :headers, :rows, :fields, :title, :objects, :last
+    def initialize(opts)
+      @objects = opts[:objects]
+      @title   = build_title(opts)
+      @rows    = opts[:rows]
+      @fields  = @rows ? nil : populate_fields(opts[:fields], @objects.first)
+      @headers = populate_headers(opts[:headers])
+    end
+
+    # Report Title
+    # @param opts[:simulate] [Boolean] Show simulation indicator
+    # @param opts[:title] [String] Report Title
+    def build_title(opts)
+      "#{opts[:title]}#{REPORT_SIM if opts[:simulate]}"
+    end
+
+    # Determine Field List
+    # @param fields [[Symbol]] Field Symbol Array
+    # @param obj [Object] Example Object
+    # @return [[Symbol]] Field List
+    def populate_fields(fields, obj = nil)
+      # Report all fields, unless specified.
+      return fields if fields
+      obj.instance_variables.map do |x|
+        x = x.to_s.delete('@')
+        obj.respond_to?(x) ? x : nil
+      end.compact if obj
+    end
+
+    # Determine Display Headers
+    # @param headers [[String]] Column Headers
+    # @return [[String]]
+    def populate_headers(headers)
+      # Use field names as headers, unless specified
+      return headers if headers
+      return @fields.map(&:to_s) if @fields
+    end
+
+    # Collect report data
+    def populate_report_rows
+      # Read data based on field list
+      return if @rows
+      @rows = []
+      @objects.each do |object|
+        @rows << @fields.map { |field| object.send(field.to_sym) }
+      end
+    end
+
+    # Display Report
+    def show
+      populate_report_rows
+      opts = { rows: @rows, headings: @headers || [], title: @title }
+      puts Terminal::Table.new(opts) unless @rows.empty?
+    end
+    alias to_s show
+  end
+end

data/lib/draftking/tqueue/future_queue_methods.rb

@@ -0,0 +1,97 @@
+
+# # Get a list of Queued posts
+# # @param offset [Integer] return queued posts starting with offset index
+# # @return [[Post]] Array of Post JSON objects
+# def some_queue(offset = 0, limit = 1)
+#   queue = @client.queue @blog_url, offset: offset, limit: limit
+#   queue.first[1]
+# end
+#
+# # Collect entire Queue
+# # @note reads in chunks of 20 posts, so runtime can be slow.
+# # @return [[Post]] Array of Post JSON objects
+# def all_queue
+#   queue = []
+#   offset = 0
+#   loop do
+#     q_t = @client.queue(@blog_url, offset: offset, limit: 50).first[1]
+#     break if q_t.empty?
+#     offset += q_t.size
+#     queue += q_t
+#   end
+#   queue
+# end
+
+# # Add a comment to Queue
+# # @param caption [string] String to add as caption
+# # @param options[:all] [bool] Process entire Queue
+# # @param options[:skip] [String] Do not modify Queued posts that contain string
+# # @return [Integer] Number of posts modified
+# def comment_queue(caption, options)
+#   queue = options[:all] ? all_queue : some_queue(0, 50)
+#   skip = options[:skip]
+#   modified = 0
+#   if skip.nil?
+#     queue.each do |d|
+#       @client.edit @blog_url, id: d['id'], reblog_key: d['reblog_key'], caption: caption, state: 'queue'
+#       modified += 1
+#     end
+#   else
+#     queue.each do |d|
+#       next if d['summary'].include?(skip)
+#       @client.edit @blog_url, id: d['id'], reblog_key: d['reblog_key'], caption: caption, state: 'queue'
+#       modified += 1
+#     end
+#   end
+#   modified
+# end
+
+# # Tag Queued posts from comment
+# # @return [Integer] Number of posts modified
+# def tag_queue
+#   puts 'Tagging Queue'
+#   queue = all_queue
+#   mod = 0
+#   queue.each do |d|
+#     caption = d['summary']
+#     next unless caption.include?('/')
+#     tags = caption.gsub(%r{[\/\\|]}, ',').gsub(' , ', ',') # Tag with caption
+#     puts "#{caption} => #{tags}"
+#     @client.edit @blog_url, id: d['id'], reblog_key: d['reblog_key'], caption: caption, tags: tags, state: 'draft'
+#     @client.edit @blog_url, id: d['id'], reblog_key: d['reblog_key'], caption: caption, tags: tags, state: 'queue'
+#     mod += 1
+#   end
+#   puts 'Done'
+#   puts "Tags added to #{mod} queue posts"
+#   mod
+# end
+
+# def auto_post(hours = 24, post_count = 50)
+#   puts "Auto-posting #{post_count} posts over #{hours} hours:"
+#   seconds = hours * 60 * 60
+#   sleep_time = seconds / post_count
+#   delay_in_mins = sleep_time / 60
+#   offset = 0
+#   limit = 1
+#   posts_left = post_count
+#   post_count.times do
+#     if posts_available && posts_left > 0
+#       publish_post(some_queue(offset, limit).first)
+#       posts_left -= 1
+#       if posts_available && posts_left > 0
+#         puts "Next post at #{Time.now + (delay_in_mins * 60)} mins"
+#         sleep sleep_time
+#       end
+#     else
+#       puts 'Processing complete!'
+#       break
+#     end
+#   end
+# end
+#
+# def publish_post(d)
+#   prInteger "Posting: #{d['summary']} .."
+#   @client.edit @blog_url, id: d['id'], reblog_key: d['reblog_key'], caption: d['summary'], tags: d['tags'], state: 'published'
+#   @q_size -= 1
+#   puts '.Done'
+# end

data/lib/draftking/version.rb

@@ -0,0 +1,3 @@
+module DK
+  VERSION = '0.7.0.4'.freeze
+end

data/lib/tasks/build.rake

@@ -0,0 +1,33 @@
+require_relative '../../codeclimate.rb'
+include BuildVars
+
+namespace :build do
+  desc 'Build gem.'
+  task :gem do
+    Rake::Task['build:readme'].execute
+    `gem build tumblr_draftking.gemspec`
+  end
+
+  desc 'Build and install gem.'
+  task :install do
+    Rake::Task['build:gem'].execute
+    file = `ls -1r *.gem | head -n 1`
+    puts `gem install #{file}`
+  end
+
+  desc 'Inject table of contents into README.md'
+  task :readme do
+    `ruby readme/generate.rb`
+  end
+
+  desc 'Prepare gem deployment.'
+  task :deployment do
+    ENV['CODECLIMATE_REPO_TOKEN'] = CODECLIMATE_REPO_TOKEN
+    ENV['CI_FLAG'] = 'true'
+    Rake::Task['rubo:fix'].execute
+    puts Rake::Task['test'].execute
+    puts Rake::Task['build:gem'].execute
+  end
+end
+
+task build: ['build:install']

data/lib/tasks/rubo.rake

@@ -0,0 +1,36 @@
+namespace :rubo do
+  desc 'Generate and display Rubocop HTML report.'
+  task :html do
+    `rubocop -f html -D --out rubocop/report.html`
+  end
+
+  desc 'Autofix Issues.'
+  task :fix do
+    `rubocop -a`
+    Rake::Task['rubo:html'].execute
+  end
+
+  desc 'AutoFix issues and display report.'
+  task :fix_report do
+    Rake::Task['rubo:fix'].execute
+    Rake::Task['rubo:gen_report'].execute
+  end
+
+  desc 'Regenerate To Do .yml'
+  task :autogen do
+    `rubocop --auto-gen-config`
+  end
+
+  desc 'Show rubocop HTML report'
+  task :gen_report do
+    `open rubocop/report.html`
+  end
+
+  desc 'Show rubocop HTML report'
+  task :report do
+    Rake::Task['rubo:html'].execute
+    Rake::Task['rubo:gen_report'].execute
+  end
+end
+
+task rubo: ['rubo:fix_report']

data/lib/tumblr_draftking.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'yaml'
+require 'tumblr_client'
+require 'thor'
+
+# Workarounds for issues with depended upon projects
+require_relative 'draftking/dependency_patches'
+
+# dk
+require_relative 'draftking/constants'
+require_relative 'draftking/version'
+require_relative 'draftking/cli'
+require_relative 'draftking/config'
+require_relative 'draftking/posts'
+require_relative 'draftking/drafts'
+require_relative 'draftking/queue'
+require_relative 'draftking/client'
+require_relative 'draftking/reporter'