Fix rubocop style issues

Author: Marthyn

.gitignore

@@ -20,3 +20,4 @@ tmp
 *.o
 *.a
 mkmf.log
+.DS_Store

.rubocop.yml

@@ -0,0 +1,54 @@
+Documentation:
+  Enabled: true
+
+AllCops:
+  Include:
+    - "**/Rakefile"
+    - "**/config.ru"
+  Exclude:
+    - "db/**/*"
+    - "tmp/**/*"
+    - "vendor/**/*"
+    - "bin/**/*"
+    - "log/**/*"
+  RunRailsCops: true
+
+Documentation:
+  Enabled: false
+Style/LineLength:
+  Max: 145
+Metrics/AbcSize:
+  Max: 30
+Metrics/BlockNesting:
+  Max: 3
+Metrics/ClassLength:
+  CountComments: false  # count full line comments?
+  Max: 100
+Metrics/CyclomaticComplexity:
+  Max: 6
+Metrics/LineLength:
+  Max: 80
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Metrics/MethodLength:
+  CountComments: false  # count full line comments?
+  Max: 13
+
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true
+
+Metrics/PerceivedComplexity:
+  Max: 7
+
+StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: nested

Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-# Gem's dependencies are specified in `wp-connector.gemspec`.
+# Gem"s dependencies are specified in `wp-connector.gemspec`.
 gemspec

README.md

@@ -10,33 +10,33 @@ This library is part of the [**WP on Rails**](https://github.com/wponrails) proj
 
 To prepare a WP installation to be used in a **WP on Rails** architecture the [**wp-relinquish**](https://github.com/wponrails/wp-relinquish) plugin is provided. It provides a means to configure WP actions to send notifications as webhook calls to a Rails application equipped with **wp-connector**.
 
-When using **WP on Rails** the content's *master data* resides in WP's database, as that's where is it created and modified.  The Rails application that is connected to WP stores merely a copy of the data, a cache, on the basis of which the public requests are served.
+When using **WP on Rails** the content"s *master data* resides in WP"s database, as that"s where is it created and modified.  The Rails application that is connected to WP stores merely a copy of the data, a cache, on the basis of which the public requests are served.
 
 The main reasons for not using WP to serve public web requests:
 
 * **Security** — The internet is a dangerous place and WordPress has proven to be a popular target for malicious hackers. By not serving public requests from WP, but only the admin interface, the attack surface is significantly reduced.
 * **Performance** — Performance tuning WP can be difficult, especially when a generic caching-proxy (such as Varnish) is not viable due to dynamic content such as ads or personalization.  Application frameworks provide means for fine-grained caching strategies that are needed to serve high-traffic websites containing dynamic content.
 * **Cost (TCO) of customizations** — Customizing WP, and maintaining those customizations, is costly (laborious) and risky (error prone) compared to building custom functionality on top of an application framework (which is specifically designed for that purpose).
 * **Upgrade path** — Keeping a customized WP installation up-to-date can be a pain, and WP-updates come ever more often. When WP is not used to serve public requests and customizations are not built into WP most of this pain avoided.
-* **Modern browser interfaces** — The new bread of JavaScript UI frameworks (such as Facebook's [React](http://facebook.github.io/react) and Google's [AngularJS](https://angularjs.org)) have features like "isomorphism" (allowing JS views to be pre-rendered on the server) and "two-way data-binding". These features expect certain server-side behavior and usually consume JSON data instead of HTML. The Rails community provides many tools to facilitate these new UI libraries from the server-side.
+* **Modern browser interfaces** — The new bread of JavaScript UI frameworks (such as Facebook"s [React](http://facebook.github.io/react) and Google"s [AngularJS](https://angularjs.org)) have features like "isomorphism" (allowing JS views to be pre-rendered on the server) and "two-way data-binding". These features expect certain server-side behavior and usually consume JSON data instead of HTML. The Rails community provides many tools to facilitate these new UI libraries from the server-side.
 
 
 ## How it works
 
 After the Rails application receives the webhook call from WP, simply notifying that some content is created or modified, a delayed job to fetch the content is scheduled using [Sidekiq](http://sidekiq.org).  The content is not fetched immediately, but scheduled for a fraction of a second later, the reason for this is twofold:
 
 1. The webhook call is synchronous, responding as soon as possible is needed to keep the admin interface of WP responsive.
-2. It is not guaranteed that all WP's processing is complete (some actions may still fire) by the time the webhook call is made.
+2. It is not guaranteed that all WP"s processing is complete (some actions may still fire) by the time the webhook call is made.
 
 The delayed job fetches the relevant content from WP using the [WP-REST-API](http://wp-api.org) (this can be one or more requests), then possibly transforms and/or enriches the data, and finally stores it using a regular ActiveRecord model. The logic for the fetch and transform/enrich steps is simply part of the ActiveRecord model definition.
 
 
 ## Installation
 
-Add this line to your Rails application's `Gemfile`:
+Add this line to your Rails application"s `Gemfile`:
 
 ```ruby
-gem 'wp-connector', :github => 'wponrails/wp-connector'
+gem "wp-connector", :github => "wponrails/wp-connector"
 ```
 
 Then execute `bundle install`.
@@ -52,7 +52,7 @@ Rails.configuration.x.wordpress_url = "http://wordpress-site.dev/"
 ```
 Here `wordpress-site.dev` is the domain for your Wordpress site.
 
-This configures some models, `['articles', 'news_articles', 'pages']`, for paginated requests to the WP-REST API.
+This configures some models, `["articles", "news_articles", "pages"]`, for paginated requests to the WP-REST API.
 ```ruby
 Rails.configuration.x.wp_api_paginated_models = %w(articles news_articles pages)
 ```
@@ -67,8 +67,8 @@ Installing the routes for the webhook endpoint (in `config/routes.rb` of your Ra
 
 ```ruby
 # wp-connector endpoints
-post   'wp-connector/:model',     to: 'wp_connector#model_save'
-delete 'wp-connector/:model/:id', to: 'wp_connector#model_delete'
+post   "wp-connector/:model",     to: "wp_connector#model_save"
+delete "wp-connector/:model/:id", to: "wp_connector#model_delete"
 ```
 
 Create a `WpConnectorController` class (in `app/controllers/wp_connector_controller.rb`) that specifies a `webhook` action. For example for the `Post` type:
@@ -176,7 +176,7 @@ class Author < ActiveRecord::Base
   # ... snip ...
 
   def self.wp_type
-    'wp_post_type_name'
+    "wp_post_type_name"
   end
 
   # ... snap ...
@@ -230,7 +230,7 @@ You know the drill :)
 
 1. Fork it.
 2. Create your feature branch (`git checkout -b my-new-feature`).
-3. Commit your changes (`git commit -am 'Add some feature'`).
+3. Commit your changes (`git commit -am "Add some feature"`).
 4. Push to the branch (`git push origin my-new-feature`).
 5. Submit a "Pull Request".
 

Rakefile

@@ -1,2 +1 @@
 require "bundler/gem_tasks"
-

app/controllers/concerns/wp_preview_tools.rb

@@ -13,13 +13,13 @@ def validate_preview_token(wp_post_model, &block)
     return if wp_post_model.status == "publish"
 
     unless params[:token] == token(wp_post_model)
-      head :unauthorized and return unless block_given?
+      head :unauthorized && return unless block_given?
 
       block.call
     end
 
     # return true for clearer debugging
-    return true
+    true
   end
 
   #
@@ -35,7 +35,7 @@ def token(wp_post_model)
   # This to avoid NotFound errors due to the delaying of WP API calls.
   #
   def retry_when_preview(retrying = false, &block)
-    raise "retry_when_preview requires a block" unless block_given?
+    fail "retry_when_preview requires a block" unless block_given?
     return block.call
   rescue ActiveRecord::ActiveRecordError => e
     raise e if !params[:preview] || retrying

app/controllers/concerns/wp_webhook_endpoint.rb

@@ -24,7 +24,7 @@ def wp_id_from_params
   # Convenience method for finding the `preview` of an incoming POST request.
   #
   def preview_from_params
-    # some systems send in a string '1' or '0' for booleans. Map it to boolean:
+    # some systems send in a string "1" or "0" for booleans. Map it to boolean:
     to_bool params[:preview]
   end
 
@@ -33,9 +33,9 @@ def preview_from_params
   #
   def render_json_200_or_404(success)
     if success
-      render json: {status: 200, message: 'OK'}
+      render json: { status: 200, message: "OK" }
     else
-      render json: {status: 404, message: 'Not found'}
+      render json: { status: 404, message: "Not found" }
     end
   end
 
@@ -49,6 +49,6 @@ def require_valid_api_key
   def to_bool(string)
     return true if string == true || string =~ (/^(true|t|yes|y|1)$/i)
     return false if string == false || string.blank? || string =~ (/^(false|f|no|n|0)$/i)
-    raise ArgumentError.new("invalid value for Boolean: \"#{string}\"")
+    fail(ArgumentError, "invalid value for Boolean: \"#{string}\"")
   end
 end

app/models/concerns/wp_cache.rb

@@ -1,10 +1,10 @@
-require 'faraday'
+require "faraday"
 
 module WpCache
   extend ActiveSupport::Concern
 
   module ClassMethods
-
+    attr_reader :classes
     #
     # Collect all class names in a class variable so that it can be accessed by the Rake task.
     #
@@ -13,17 +13,10 @@ def included(base)
       @classes << base.name
     end
 
-    #
-    # Returns an array WpCache classes.
-    #
-    def classes
-      @classes
-    end
-
     #
     # Schedules a `create_or_update` call to itself.
     #
-    # TODO (cies): add a configurable amount of delay, defaulting to 0.5secs
+    # TODO: (cies) add a configurable amount of delay, defaulting to 0.5secs
     def schedule_create_or_update(wp_id, preview = false, request = nil)
       extra_info = request ? " after #{request.fullpath} -- #{request.body.read}" : ""
       Rails.logger.info("SCHEDULED by #{self.class}" + extra_info)
@@ -35,12 +28,12 @@ def schedule_create_or_update(wp_id, preview = false, request = nil)
     # and passes it the content by the `update_wp_cache` instance method.
     #
     def create_or_update(wp_type, wp_id, preview = false)
-      return unless wp_id.is_a? Fixnum or wp_id.is_a? String
+      return unless wp_id.is_a?(Fixnum) || wp_id.is_a?(String)
       maybe_preview_segment = (preview ? "preview/" : "")
       wp_json = get_from_wp_api "#{ wp_type }/#{ maybe_preview_segment }#{ wp_id }"
       # WP API will return a code if the route is incorrect or
       # the specified entry is none existant. If so return early.
-      return if wp_json[0] and invalid_api_responses.include? wp_json[0]["code"]
+      return if wp_json[0] && invalid_api_responses.include?(wp_json[0]["code"])
       where(wp_id: wp_id).first_or_initialize.update_wp_cache(wp_json)
     end
 
@@ -58,34 +51,38 @@ def create_or_update_all
     # the `update_wp_cache` instance method.
     # Removes records with unknown IDs.
     #
-    # TODO (dunyakirkali) clean up
+    # TODO: (dunyakirkali) clean up
     def create_or_update_all_paginated
       page = 0
       ids = []
-      max_page = (ENV['MAX_PAGE'].to_i == 0 ? 999 : ENV['MAX_PAGE'].to_i)
-      while page < max_page do
+      max_page = (ENV["MAX_PAGE"].to_i == 0 ? 999 : ENV["MAX_PAGE"].to_i)
+      while page < max_page
         Rails.logger.info " page #{page}"
         wp_json = get_from_wp_api(wp_type, page)
         break if wp_json.empty?
-        ids << wp_json.map do |json|
-          wp_id = json['ID']
-          where(wp_id: wp_id).first_or_initialize.update_wp_cache(json)
-          wp_id
-        end
-        page = page + 1
+        ids << map_ids(wp_json)
+        page += 1
       end
-      where('wp_id NOT IN (?)', ids.flatten).destroy_all unless ids.empty?
+      where("wp_id NOT IN (?)", ids.flatten).destroy_all unless ids.empty?
     end
 
-    # TODO (dunyakirkali) doc
+    def map_ids
+      wp_json.map do |json|
+        wp_id = json["ID"]
+        where(wp_id: wp_id).first_or_initialize.update_wp_cache(json)
+        wp_id
+      end
+    end
+
+    # TODO: (dunyakirkali) doc
     def create_or_update_all_non_paginated
       wp_json = get_from_wp_api(wp_type)
       ids = wp_json.map do |json|
-        wp_id = json['ID']
+        wp_id = json["ID"]
         where(wp_id: wp_id).first_or_initialize.update_wp_cache(json)
         wp_id
       end
-      where('wp_id NOT IN (?)', ids).destroy_all unless ids.empty?
+      where("wp_id NOT IN (?)", ids).destroy_all unless ids.empty?
     end
 
     #
@@ -102,15 +99,15 @@ def purge(wp_id)
     #
     # Convenience method for calling the WP API.
     #
-    # TODO (cies): re-raise any connection errors with more intuitive names
+    # TODO: (cies) re-raise any connection errors with more intuitive names
     def get_from_wp_api(route, page = -1)
-      # TODO (dunyakirkali) pass filter through args to get_from_wp_api
-      posts_per_page = (ENV['PER_PAGE'].to_i == -1 ? -1 : ENV['PER_PAGE'].to_i)
+      # TODO: (dunyakirkali) pass filter through args to get_from_wp_api
+      posts_per_page = (ENV["PER_PAGE"].to_i == -1 ? -1 : ENV["PER_PAGE"].to_i)
       base = Rails.configuration.x.wordpress_url
-      unless paginated_models.include?(wp_type)
-        url = "#{base}?json_route=/#{route}&filter[posts_per_page]=-1"
-      else
+      if paginated_models.include?(wp_type)
         url = "#{base}?json_route=/#{route}&filter[posts_per_page]=#{posts_per_page}&page=#{page}"
+      else
+        url = "#{base}?json_route=/#{route}&filter[posts_per_page]=-1"
       end
       Rails.logger.info url
       response = Faraday.get url
@@ -136,7 +133,7 @@ def paginated_models
     #
     # List of invalid api responses
     #
-    # TODO (cies): refactor to WpCache::WP_API_ERROR_CODES
+    # TODO: (cies) refactor to WpCache::WP_API_ERROR_CODES
     def invalid_api_responses
       %w( json_no_route json_post_invalid_type json_user_cannot_read )
     end

app/models/concerns/wp_menu.rb

@@ -14,7 +14,7 @@ def update_menu(json)
 
   module ClassMethods
     def wp_type
-      'menus'
+      "menus"
     end
   end
 end

app/models/concerns/wp_post.rb

@@ -5,27 +5,27 @@ module WpPost
     serialize :acf_fields
   end
 
-  # TODO (cies): rename to update_wp_post_attributes
+  # TODO: (cies) rename to update_wp_post_attributes
   def update_post(json)
     self.class.mappable_wordpress_attributes.each do |wp_attribute|
       send("#{wp_attribute}=", json[wp_attribute])
     end
 
-    self.wp_id        = json['ID']
+    self.wp_id        = json["ID"]
     # Use gmt date to ignore timezone settings in WordPress
-    self.published_at = json['date_gmt']
-    self.order        = json['menu_order']
+    self.published_at = json["date_gmt"]
+    self.order        = json["menu_order"]
     save!
   end
 
   module ClassMethods
-    # TODO (cies): refactor to constant WpPost::MAPPABLE_ATTRS
+    # TODO: (cies) refactor to constant WpPost::MAPPABLE_ATTRS
     def mappable_wordpress_attributes
       %w( slug title status content excerpt acf_fields )
     end
 
     def wp_type
-      self.to_s.demodulize.underscore.pluralize
+      to_s.demodulize.underscore.pluralize
     end
   end
 end

app/models/concerns/wp_seo.rb

@@ -7,7 +7,7 @@ module WpSEO
 
   def update_wp_seo_attributes(json)
     return unless json.is_a?(Hash)
-    self.seo_fields = json['seo_fields']
+    self.seo_fields = json["seo_fields"]
     save!
   end
 end