the_comments_ruby 2.3.3

data/docs/routes.md

@@ -0,0 +1,77 @@
+←   [documentation](documentation.md)
+
+## TheComments Routes
+
+**config/routes.rb**
+
+```ruby
+MyApp::Application.routes.draw do
+  root 'posts#index'
+  resources :posts
+
+  # ...
+
+  # TheComments routes
+  concern   :user_comments,  TheComments::UserRoutes.new
+  concern   :admin_comments, TheComments::AdminRoutes.new
+  resources :comments, concerns:  [:user_comments, :admin_comments]
+end
+```
+
+And after that you can see routes:
+
+```ruby
+rake routes | grep comments
+```
+
+```ruby
+ comments        /                         TheComments::Engine
+         to_spam_comment POST   /comments/:id/to_spam(.:format)      comments#to_spam
+        to_draft_comment POST   /comments/:id/to_draft(.:format)     comments#to_draft
+    to_published_comment POST   /comments/:id/to_published(.:format) comments#to_published
+      to_deleted_comment DELETE /comments/:id/to_deleted(.:format)   comments#to_deleted
+         manage_comments GET    /comments/manage(.:format)           comments#manage
+       my_draft_comments GET    /comments/my_draft(.:format)         comments#my_draft
+   my_published_comments GET    /comments/my_published(.:format)     comments#my_published
+    my_comments_comments GET    /comments/my_comments(.:format)      comments#my_comments
+    total_draft_comments GET    /comments/total_draft(.:format)      comments#total_draft
+total_published_comments GET    /comments/total_published(.:format)  comments#total_published
+  total_deleted_comments GET    /comments/total_deleted(.:format)    comments#total_deleted
+     total_spam_comments GET    /comments/total_spam(.:format)       comments#total_spam
+          draft_comments GET    /comments/draft(.:format)            comments#draft
+      published_comments GET    /comments/published(.:format)        comments#published
+        deleted_comments GET    /comments/deleted(.:format)          comments#deleted
+           spam_comments GET    /comments/spam(.:format)             comments#spam
+                comments GET    /comments(.:format)                  comments#index
+                         POST   /comments(.:format)                  comments#create
+             new_comment GET    /comments/new(.:format)              comments#new
+            edit_comment GET    /comments/:id/edit(.:format)         comments#edit
+                 comment GET    /comments/:id(.:format)              comments#show
+                         PATCH  /comments/:id(.:format)              comments#update
+                         PUT    /comments/:id(.:format)              comments#update
+                         DELETE /comments/:id(.:format)              comments#destroy
+```
+
+And now you can use url helpers with 2 ways:
+
+### Way 1. Url Helpers
+
+```ruby
+= link_to 'link', comments_path
+= link_to 'link', manage_comments_path
+= link_to 'link', new_comment_path
+
+= link_to 'link', comment_path(@comment)
+= link_to 'link', to_spam_comment_path(@comment)
+```
+
+### Way 2. Array notation
+
+```ruby
+= link_to 'link', [:index,  :comments]
+= link_to 'link', [:manage, :comments]
+= link_to 'link', [:draft,  :comments]
+
+= link_to 'link', [@comment]
+= link_to 'link', [:to_spam, @comment]
+```

data/docs/user_api.md

@@ -0,0 +1,75 @@
+←   [documentation](documentation.md)
+
+### User API
+
+**When User is not commentable model**
+
+```ruby
+class User < ActiveRecord::Base
+  include TheCommentsUser
+
+  has_many :posts     # commentable model
+  has_many :products  # commentable model
+end
+```
+
+:warning: &nbsp; Please, read this: [What is ComComs?](what_is_comcoms.md)
+
+
+We can use following methods
+
+```ruby
+@user = User.first
+
+@user.comcoms #=> all comments for posts and products, where user is owner
+
+# cache counters
+@user.draft_comcoms_count     # => 1
+@user.published_comcoms_count # => 5
+@user.deleted_comcoms_count   # => 3
+@user.spam_comcoms_count      # => 2
+
+# equal values, but with request to database
+@user.comcoms.with_state([:draft]).count      # => 1
+@user.comcoms.with_state([:published]).count  # => 5
+@user.comcoms.with_state([:deleted]).count    # => 3
+@user.comcoms.where(spam: true).count         # => 2
+
+# draft and published comments
+# written by this user
+@user.my_comments  # => ActiveRecord::Relation
+
+# cache counters for comments
+# written by this user
+# there is no cache counter for deleted state!
+@user.my_draft_comments_count         # => 3
+@user.my_published_comments_count     # => 7
+
+# equal values, but with request to database
+@user.my_draft_comments.count       # => 3
+@user.my_published_comments.count   # => 7
+@user.my_deleted_comments.count     # => 1
+
+# helper methods to get comments
+# written by this user
+@user.my_draft_comments      # => ActiveRecord::Relation
+@user.my_published_comments  # => ActiveRecord::Relation
+@user.my_deleted_comments    # => ActiveRecord::Relation
+
+# recalculate cache counters
+@user.recalculate_my_comments_counter!
+```
+
+**When User is commentable model**
+
+```ruby
+class User < ActiveRecord::Base
+  include TheCommentsUser
+  include TheCommentsCommentable
+
+  has_many :posts     # commentable model
+  has_many :products  # commentable model
+end
+```
+
+you should to use following instruction [Commentable API](commentable_api.md)

data/docs/what_is_comcoms.md

@@ -0,0 +1,63 @@
+←   [documentation](documentation.md)
+
+### What is ComComs?
+
+:warning:   **comcoms** - is main method to get all comments related with user's commentable models.
+
+:warning:   **comments** - is main method to get comments related with any commentable model.
+
+**ComComs** - **com**ments of **com**mentable models
+
+ComComs are all incoming comments for all models, where this user is owner.
+
+For example, some user **has_many :posts**, and  **has_many :products** - all comments for all user's posts and all user's products called as **comcoms**.
+
+#### Why we need ComComs?
+
+User model can be commentable too. For example to build user's "public wall" (like tweets list for current user).
+
+And we should to separate **comments** attached to user model (tweets) and comments attached to any another user's model.
+
+That is why User model in-fact has following relationship declarations:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :comcoms, class_name: :Comment, foreign_key: :holder_id
+  
+  # and if User model is commentable model
+  # has_many :comments, as: :commentable
+  
+  has_many :posts
+  has_many :products
+end
+```
+
+in real application it should be described like this:
+
+```ruby
+class User < ActiveRecord::Base
+  include TheCommentsUser
+  include TheCommentsCommentable
+  
+  has_many :posts
+  has_many :products
+end
+```
+
+But in most popular situation User model should not be commentable, and you should use only **comcoms** method to get all comments related with this user:
+
+```ruby
+class User < ActiveRecord::Base
+  include TheCommentsUser
+
+  has_many :posts
+  has_many :products
+end
+```
+
+and later in your application
+
+```ruby
+@user = User.find params[:id]
+@user.comcoms.count # => 42
+```

data/docs/whats_wrong_with_other_gems.md

@@ -0,0 +1,28 @@
+←   [documentation](documentation.md)
+
+### What's wrong with other gems?
+
+Take a look at [Ruby-Toolbox](https://www.ruby-toolbox.com/categories/rails_comments). What can we see?
+
+* [Acts as commentable with threading](https://github.com/elight/acts_as_commentable_with_threading) - Where is the render helper for the tree? There is no helper! Am I supposed to write a render helper for the tree myself? Nooooo!!! I'm sorry, I can't use this gem. 
+* [acts_as_commentable](https://github.com/jackdempsey/acts_as_commentable) - I can see the code for models. But I can't see the code for controllers and views. Unfortunately, there is no threading. This isn't enough for me.
+* [opinio](https://github.com/Draiken/opinio) - Better, but still no threading. I can do better!
+* [has_threaded_comments](https://github.com/aarongough/has_threaded_comments) - A solid gem. Has model, controller and view helpers for tree rendering! **But** last activity was 2 years ago, it still needs a few features - I can do better.
+
+### Why is TheComments better than other gems?
+
+1. TheComments allows for threaded comments
+2. **Only TheComments has special helper for tree rendering** (based on [TheSortableTree](https://github.com/the-teacher/the_sortable_tree)).
+3. TheComments is designed to reduce database requests. Helpful for cache counters.
+4. TheComments has a solution for [building Recent Comments](https://github.com/the-teacher/the_comments/blob/master/docs/denormalization_and_recent_comments.md) (for polymorphic relations)
+5. TheComments is designed for text preprocessors (Textile, Markdown, Sanitize, Coderay etc.)
+6. TheComments has an admin UI based on bootstrap 3
+7. TheComments is an "all-in-one" solution.<br>
+   It has: Models and Controllers logic (via concerns), Generators, Views, Helper for fast Tree rendering and Admin UI.
+8. If you have problems with TheComments, I'll try to help you via skype: **ilya.killich**
+   
+### TheComments based on:
+
+1. [AwesomeNestedSet](https://github.com/collectiveidea/awesome_nested_set) - for comments threading
+2. [TheSortableTree](https://github.com/the-teacher/the_sortable_tree) - for fast rendering of comments tree
+3. [State Machine](https://github.com/pluginaweek/state_machine) - to provide easy and correct recalculation cache counters on states transitions

data/docs/where_is_example_application.md

@@ -0,0 +1,37 @@
+←   [documentation](documentation.md)
+
+### Dummy Application
+
+TheComments repository contains a dummy application for development and testing.
+
+It's here: [Dummy App](https://github.com/the-teacher/the_comments/tree/master/spec/dummy_app)
+
+To run the dummy app:
+
+```ruby
+git clone https://github.com/the-teacher/the_comments.git
+
+cd the_comments/spec/dummy_app/
+
+bundle
+
+rake db:bootstrap_and_seed
+
+rails s -p 3000 -b localhost
+```
+
+### Run tests
+
+To run the RSPEC tests:
+
+```ruby
+git clone https://github.com/the-teacher/the_comments.git
+
+cd the_comments/spec/dummy_app/
+
+bundle
+
+rake db:bootstrap RAILS_ENV=test
+
+rspec --format documentation
+```

data/gem_version.rb

@@ -0,0 +1,3 @@
+module TheComments
+  VERSION = "2.3.3"
+end

data/lib/generators/the_comments/USAGE

@@ -0,0 +1,44 @@
+Description:
+  TheComments: generators will copy files for organize comments tree in your web project
+
+  Usage: [bundle exec] rails g the_comments NAME
+  Usage: [bundle exec] rails g the_comments:views NAME
+
+# This text:
+  > rails g the_comments --help
+
+# Main generators:
+  > rails g the_comments install
+
+  This will create:
+   config/initializers/the_comments.rb
+   app/controllers/comments_controller.rb
+   app/models/comment.rb
+
+# Controller generators:
+  > rails g the_comments controllers
+
+  This will create:
+    app/controllers/comments_controller.rb
+    
+# Model generators:
+  > rails g the_comments models
+  
+  This will create:
+    app/models/comment.rb
+
+# Config generators:
+  > rails g the_comments config
+
+# Locals generators:
+  > rails g the_comments locales
+
+# View Generators:
+  > rails g the_comments:views js
+  > rails g the_comments:views css
+  > rails g the_comments:views assets
+  > rails g the_comments:views helper
+  > rails g the_comments:views views
+
+# Migrations:
+  > rake the_comments_engine:install:migrations

data/lib/generators/the_comments/the_comments_generator.rb

@@ -0,0 +1,56 @@
+class TheCommentsGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+  # argument :xname, type: :string, default: :xname
+
+  # > rails g the_comments NAME
+  def generate_controllers
+    case gen_name
+      when 'locales'
+        cp_locales
+      when 'models'
+        cp_models
+      when 'controllers'
+        cp_controllers
+      when 'config'
+        cp_config
+      when 'install'
+        cp_config
+        cp_models
+        cp_controllers
+      else
+        puts 'TheComments Generator - wrong Name'
+        puts 'Try to use [ install | config | controllers | models ]'
+    end
+  end
+
+  private
+
+  def root_path; TheComments::Engine.root; end
+
+  def gen_name
+    name.to_s.downcase
+  end
+
+  def cp_config
+    copy_file "#{root_path}/config/initializers/the_comments.rb",
+              "config/initializers/the_comments.rb"
+  end
+
+  def cp_models
+    copy_file "#{root_path}/app/models/_templates_/comment.rb",
+              "app/models/comment.rb"
+  end
+
+  def cp_controllers
+    copy_file "#{root_path}/app/controllers/_templates_/comments_controller.rb",
+              "app/controllers/comments_controller.rb"
+  end
+
+  def cp_locales
+    copy_file "#{root_path}/config/locales/en.yml",
+              "config/locales/en.the_comments.yml"
+
+    copy_file "#{root_path}/config/locales/ru.yml",
+              "config/locales/ru.the_comments.yml"
+  end
+end

data/lib/generators/the_comments/views_generator.rb

@@ -0,0 +1,79 @@
+module TheComments
+  module Generators
+    class ViewsGenerator < Rails::Generators::NamedBase
+      source_root TheComments::Engine.root
+
+      def self.banner
+<<-BANNER.chomp
+
+USAGE: [bundle exec] rails g the_comments:views NAME
+
+> rails g the_comments:views js
+> rails g the_comments:views css
+> rails g the_comments:views assets
+
+> rails g the_comments:views views
+> rails g the_comments:views helper
+
+> rails g the_comments:views all
+
+BANNER
+      end
+
+      def copy_sortable_tree_files
+        copy_gem_files
+      end
+
+      private
+
+      def param_name
+        name.downcase
+      end
+
+      def copy_gem_files
+        case param_name
+          when 'js'
+            js_copy
+          when 'css'
+            css_copy
+          when 'assets'
+            js_copy; css_copy
+          when 'views'
+            views_copy
+          when 'helper'
+            helper_copy
+          when 'all'
+            js_copy
+            css_copy
+            views_copy
+            helper_copy
+          else
+            puts 'TheComments View Generator - wrong Name'
+            puts "Wrong params - use only [ js | css | assets | views | helper | all ] values"
+        end
+      end
+
+      def js_copy
+        f1 = "app/assets/javascripts/the_comments.js.coffee"
+        f2 = "app/assets/javascripts/the_comments_manage.js.coffee"
+        copy_file f1, f1
+        copy_file f2, f2
+      end
+
+      def css_copy
+        f1 = "app/assets/stylesheets/the_comments.css.scss"
+        copy_file f1, f1
+      end
+
+      def views_copy
+        d1 = "app/views/the_comments"
+        directory d1, d1
+      end
+
+      def helper_copy
+        f1 = "app/helpers/render_comments_tree_helper.rb"
+        copy_file f1, f1
+      end
+    end
+  end
+end

data/lib/the_comments/config.rb

@@ -0,0 +1,37 @@
+module TheComments
+  def self.configure(&block)
+    yield @config ||= TheComments::Configuration.new
+  end
+
+  def self.config
+    @config
+  end
+
+  # Configuration class
+  class Configuration
+    include ActiveSupport::Configurable
+
+    config_accessor :max_reply_depth,
+                    :tolerance_time,
+                    :default_state,
+                    :default_owner_state,
+                    :empty_inputs,
+                    :default_title,
+                    :template_engine,
+                    :empty_trap_protection,
+                    :tolerance_time_protection
+  end
+
+  configure do |config|
+    config.max_reply_depth     = 3
+    config.tolerance_time      = 5
+    config.default_state       = :draft
+    config.default_owner_state = :published
+    config.empty_inputs        = [:message]
+    config.default_title       = 'Undefined title'
+    config.template_engine     = :haml
+
+    config.empty_trap_protection     = true
+    config.tolerance_time_protection = true
+  end
+end

data/lib/the_comments/version.rb

@@ -0,0 +1 @@
+require File.expand_path('../../../gem_version', __FILE__)

data/lib/the_comments.rb

@@ -0,0 +1,28 @@
+require 'state_machine'
+require 'state_machine/version'
+
+require 'the_simple_sort'
+require 'the_sortable_tree'
+
+require 'the_comments/config'
+require 'the_comments/version'
+
+module TheComments
+  COMMENTS_COOKIES_TOKEN = 'JustTheCommentsCookies'
+
+  class Engine < Rails::Engine
+    config.autoload_paths += Dir["#{config.root}/app/controllers/concerns/**/"]
+    config.autoload_paths += Dir["#{config.root}/app/models/concerns/**/"]
+  end
+end
+
+# Loading of concerns
+_root_ = File.expand_path('../../',  __FILE__)
+require "#{_root_}/config/routes.rb"
+
+if StateMachine::VERSION.to_f <= 1.2
+  module StateMachine::Integrations::ActiveModel
+    puts "You should not in here"
+    public :around_validation
+  end
+end

data/spec/dummy_app/.gitignore

@@ -0,0 +1,18 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+.rvmrc
+
+# Ignore the default SQLite database.
+/db/*.db
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/spec/dummy_app/.rspec

@@ -0,0 +1 @@
+--color

data/spec/dummy_app/Gemfile

@@ -0,0 +1,43 @@
+source 'https://rubygems.org'
+
+# Base gems
+gem 'rails', '4.1.4 ' #github: 'rails/rails', branch: 'master'
+gem 'sqlite3'
+
+gem 'jquery-rails'
+gem 'jbuilder', '~> 1.2'
+
+gem 'uglifier', '>= 1.3.0'
+gem 'sass-rails', '~> 4.0.0'
+gem 'coffee-rails', '~> 4.0.0'
+
+gem 'thin', group: [:development]
+# gem 'therubyracer', platforms: :ruby
+gem 'sdoc', require: false, group: [:doc]
+
+# App gems
+gem 'haml'
+gem 'sorcery'
+gem 'kaminari'
+gem 'haml-rails'
+
+# TheComments requires
+gem 'the_comments',
+  path: '../../'
+
+gem 'bootstrap-sass',
+  github: 'thomas-mcdonald/bootstrap-sass'
+
+gem 'awesome_nested_set',
+  git: 'https://github.com/collectiveidea/awesome_nested_set.git',
+  branch: 'master'
+
+# Test gems
+group :development, :test do
+  gem 'faker'
+  gem 'factory_girl'
+  gem "factory_girl_rails"
+  gem 'rspec-rails', '~> 2.0'
+
+  # gem 'database_cleaner'
+end

data/spec/dummy_app/README.md

@@ -0,0 +1,33 @@
+## TheComments Dummy App
+
+### First step
+
+```
+git clone https://github.com/the-teacher/the_comments.git
+
+cd the_comments/spec/dummy_app/
+
+bundle
+```
+
+### App start
+
+```
+rake db:bootstrap_and_seed
+
+rails s -p 3000 -b localhost
+```
+
+Browser
+
+```
+http://localhost:3000/
+```
+
+### Tests start
+
+```
+rake db:bootstrap RAILS_ENV=test
+
+rspec --format documentation
+```

data/spec/dummy_app/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+App::Application.load_tasks

data/spec/dummy_app/app/assets/javascripts/admin_panel.js

@@ -0,0 +1,5 @@
+//= require jquery
+//= require jquery_ujs
+
+//= require bootstrap
+//= require the_comments_manage