hashtags 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/locales/hashtags/builder.en.yml

@@ -0,0 +1,5 @@
+en:
+  hashtags/builders:
+    help:
+      type: type
+      for: for

data/config/routes.rb

@@ -0,0 +1,5 @@
+Hashtags::Engine.routes.draw do
+  namespace :hashtags do
+    get 'resources' => 'resources#index', as: :resources
+  end
+end

data/hashtags.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hashtags/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hashtags'
+  spec.version       = Hashtags::VERSION
+  spec.authors       = ['Tomas Celizna']
+  spec.email         = ['tomas.celizna@gmail.com']
+
+  spec.summary       = 'Rails engine to facilitate inline text hashtags.'
+  spec.homepage      = 'https://github.com/tomasc/hashtags'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'handlebars'
+  spec.add_dependency 'rails', '~> 4'
+  spec.add_dependency 'rails-assets-jquery-textcomplete'
+  spec.add_dependency 'rails-assets-handlebars'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'mongoid', '~> 5.0'
+  spec.add_development_dependency 'slim'
+end

data/lib/assets/javascripts/hashtags.js

@@ -0,0 +1,3 @@
+//= require jquery-textcomplete
+//= require handlebars
+//= require hashtags/hashtags

data/lib/assets/javascripts/hashtags/hashtags.coffee

@@ -0,0 +1,66 @@
+#= require handlebars
+#= require jquery-textcomplete
+
+# https://github.com/zenorocha/jquery-boilerplate
+(($, window) ->
+  pluginName = 'hashtags'
+  document = window.document
+
+  defaults =
+    debug: false
+
+  class Plugin
+    constructor: (@element, options) ->
+      @options = $.extend {}, defaults, options
+
+      @$element = $(@element)
+
+      @_defaults = defaults
+      @_name = pluginName
+
+      @init()
+
+    init: ->
+      @$element.textcomplete(@get_strategies())
+
+    get_data: -> @$element.data 'hashtags'
+    get_default_path: -> @get_data()['path']
+    get_strategies: -> $.map @get_data()['strategies'], (strategy) => @get_strategy(strategy)
+    get_strategy: (data) ->
+      {
+        index: data.match_index
+        cache: true
+        context: (text) -> text.toLowerCase()
+        match: ///#{data.match_regexp}///
+        search: (term, callback, match) =>
+          if data.values then @search_values(data, term, callback, match)
+          else @search_remote(data, term, callback, match)
+        replace: (resource, event) -> Handlebars.compile(data.replace)(resource)
+        template: (resource, term) -> Handlebars.compile(data.template)(resource)
+      }
+
+    search_values: (data, term, callback, match) ->
+      callback $.map( data.values, (value) ->
+        if value.match(///^#{term}///i) then value else null
+      )
+
+    search_remote: (data, term, callback, match) ->
+      url = data.path ? @get_default_path()
+      match_template = data.match_template
+
+      $.getJSON( url , q: term, class_name: data.class_name )
+        .done( (resp) ->
+          callback $.map( resp, (resource) ->
+            if Handlebars.compile(match_template)(resource).match(///#{term}///i) then resource else null
+          )
+        )
+        .fail -> callback []
+
+  $.fn[pluginName] = (options) ->
+    @each ->
+      if !$.data(this, "plugin_#{pluginName}")
+        $.data(@, "plugin_#{pluginName}", new Plugin(@, options))
+
+)(jQuery, window)
+
+$ -> $('input[type="text"][data-hashtags], textarea[data-hashtags]').hashtags()

data/lib/assets/stylesheets/hashtags.css

@@ -0,0 +1,3 @@
+/*
+ *= require_tree .
+*/

data/lib/assets/stylesheets/hashtags/help.scss

@@ -0,0 +1,11 @@
+.hashtags.help {
+  .trigger_group {
+    &:not(:last-child):after {
+      content: '; ';
+    }
+
+    .item:not(:last-child):after {
+      content: ', ';
+    }
+  }
+}

data/lib/assets/stylesheets/hashtags/textcomplete.scss

@@ -0,0 +1,21 @@
+ul.textcomplete-dropdown {
+  background-color: white;
+  border: 1px solid;
+  list-style: none;
+  margin: 0;
+  padding: 0;
+
+  li.textcomplete-item {
+    border-radius: 0;
+    margin: 0;
+    padding: .25em .5em;
+    &:not(:last-child) {
+      border-bottom: 1px solid;
+    }
+
+    &:hover, &.active {
+      cursor: pointer;
+      background-color: yellow;
+    }
+  }
+}

data/lib/hashtags.rb

@@ -0,0 +1,11 @@
+require 'hashtags/base'
+require 'hashtags/builder'
+
+require 'hashtags/mongoid_extension'
+require 'hashtags/resource_type'
+require 'hashtags/resource'
+require 'hashtags/user'
+require 'hashtags/variable'
+
+require 'hashtags/engine'
+require 'hashtags/version'

data/lib/hashtags/base.rb

@@ -0,0 +1,161 @@
+module Hashtags
+  # Base class, from which all Hashtag types inherit
+  # In case you wish to add a new type next to
+  # • ResourceType
+  # • Resource
+  # • User
+  # • Variable
+  # you might want to inherit from Base.
+
+  class Base < Struct.new(:str)
+    def self.to_markup(str)
+      new(str).to_markup
+    end
+
+    def self.to_hashtag(str)
+      new(str).to_hashtag
+    end
+
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    def self.resource_classes
+      Resource.descendants
+    end
+
+    def self.user_classes
+      User.descendants
+    end
+
+    def self.variable_classes
+      Variable.descendants
+    end
+
+    # to be passed to textcomplete
+    def self.strategy(hashtag_classes)
+      {
+        class_name: to_s,
+        match_regexp: json_regexp(match_regexp),
+        match_index: match_index,
+        match_template: match_template,
+        path: path,
+        replace: replace,
+        template: template,
+        values: values(hashtag_classes)
+      }
+    end
+
+    # for example @ # $ …
+    def self.trigger
+      raise NotImplementedError
+    end
+
+    def self.match_template
+    end
+
+    # used to expire field with tags
+    def self.cache_key
+      raise NotImplementedError
+    end
+
+    # regexp to recognize the complete tag
+    def self.regexp
+      raise NotImplementedError
+    end
+
+    # implement to use custom controller
+    def self.path
+    end
+
+    # implement to preload hash tag values,
+    # fe in case there is limited number (ie variable names)
+    def self.values(hashtag_classes)
+    end
+
+    # implement to show which values particular trigger offers
+    # fe # -> lists all available resource types
+    def self.help_values
+    end
+
+    # ---------------------------------------------------------------------
+    # JS
+
+    # trigger dropdown when user input matches this regexp
+    def self.match_regexp
+      raise NotImplementedError
+    end
+
+    # index of the match group from the above regexp to be used for matching
+    def self.match_index
+      raise NotImplementedError
+    end
+
+    # tag that gets inserted into the field
+    def self.replace
+      raise NotImplementedError
+    end
+
+    # fragment to be displayed in the dropdown menu
+    def self.template
+      raise NotImplementedError
+    end
+
+    # ---------------------------------------------------------------------
+
+    # return JSON version of resources that match query
+    # this is returned when user starts typing (the query)
+    def self.json_for_query(query)
+      raise NotImplementedError
+    end
+
+    def self.values(hashtag_classes = Variable.descendants)
+    end
+
+    # ---------------------------------------------------------------------
+
+    # converts Ruby tegexp to JS regexp
+    def self.json_regexp(regexp)
+      str = regexp.inspect
+                  .sub('\\A', '^')
+                  .sub('\\Z', '$')
+                  .sub('\\z', '$')
+                  .sub(/^\//, '')
+                  .sub(/\/[a-z]*$/, '')
+                  .gsub(/\(\?#.+\)/, '')
+                  .gsub(/\(\?-\w+:/, '(')
+                  .gsub(/\s/, '')
+      Regexp.new(str).source
+    end
+
+    # ---------------------------------------------------------------------
+
+    # Converts hash tags to markup
+    def to_markup
+      str.to_s.gsub(self.class.regexp) do |match|
+        m = markup(Regexp.last_match)
+        match = m || match
+      end
+    end
+
+    # Updates hash tags
+    def to_hashtag
+      str.to_s.gsub(self.class.regexp) do |match|
+        ht = hashtag(Regexp.last_match)
+        match = ht || match
+      end
+    end
+
+    # ---------------------------------------------------------------------
+
+    # the proper hashtag (so it can be updated automatically)
+    def hashtag(match)
+      raise NotImplementedError
+    end
+
+    # what is the hashtag replaced with in the end
+    def markup(match)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/hashtags/builder.rb

@@ -0,0 +1,81 @@
+module Hashtags
+  class Builder < Struct.new(:options)
+    def self.to_markup(str, options = {})
+      new(options).to_markup(str)
+    end
+
+    def self.to_hashtag(str, options = {})
+      new(options).to_hashtag(str)
+    end
+
+    def self.dom_data(options = {})
+      new(options).dom_data
+    end
+
+    def self.help(options = {})
+      new(options).help
+    end
+
+    def initialize(options = {})
+      super(options)
+    end
+
+    # collects markup from all hashtags classes
+    def to_markup(str)
+      hashtag_classes.inject(str) { |res, cls| cls.to_markup(res) }
+    end
+
+    # collects hashtags from all hashtags classes
+    def to_hashtag(str)
+      hashtag_classes.inject(str) { |res, cls| cls.to_hashtag(res) }
+    end
+
+    # render textcomplete dom data
+    def dom_data
+      { hashtags: {
+        path: Engine.routes.url_helpers.hashtags_resources_path,
+        strategies: hashtag_strategies
+      } }
+    end
+
+    # render help string
+    def help
+      hashtag_classes.group_by(&:trigger).map do |trigger, cls|
+        OpenStruct.new(hashtag_classes: cls, trigger: trigger, help_values: cls.map(&:help_values).flatten.compact.sort)
+      end
+    end
+
+    def filter_classes(cls)
+      return [] unless cls.present?
+      res = cls
+      res &= options[:only] if options[:only]
+      res -= options[:except] if options[:except]
+      res
+    end
+
+    private
+
+    def hashtag_classes
+      filter_classes(
+        Resource.resource_classes +
+        User.user_classes +
+        Variable.variable_classes
+      )
+    end
+
+    def hashtag_strategies
+      cls = hashtag_classes.dup
+
+      # add resource type strategy if needed
+      cls << ResourceType if cls.any? { |c| c < Resource } && !cls.include?(ResourceType)
+
+      # remove all variable classes and replace them with one strategy
+      if variable_cls = cls.select { |c| c < Variable } && variable_cls.present?
+        cls -= variable_cls
+        cls << Variable
+      end
+
+      cls.collect { |c| c.strategy(hashtag_classes) }
+    end
+  end
+end

data/lib/hashtags/engine.rb

@@ -0,0 +1,7 @@
+module Hashtags
+  class Engine < ::Rails::Engine
+    engine_name = :hashtags
+
+    I18n.load_path += Dir[Engine.root.join('config', 'locales', '**', '*.{rb,yml}')]
+  end
+end

data/lib/hashtags/mongoid_extension.rb

@@ -0,0 +1,36 @@
+require 'mongoid'
+require 'ostruct'
+
+Mongoid::Fields.option :hashtags do |cls, field, value|
+  return if value == false
+
+  cls.define_singleton_method(:hashtags) { @hashtags ||= {} } unless cls.respond_to?(:hashtags)
+  options = value.is_a?(Hash) ? value.slice(*%i(only except)) : {}
+
+  cls.hashtags[field.name].define_singleton_method :dom_data do
+    Hashtags::Builder.dom_data(options)
+  end
+
+  cls.hashtags[field.name].define_singleton_method :help do
+    Hashtags::Builder.help(options)
+  end
+
+  cls.hashtags[field.name].define_singleton_method :options do
+    options
+  end
+
+  field.define_singleton_method :demongoize do |*args|
+    res = super(*args)
+    res.define_singleton_method :to_markup do
+      Hashtags::Builder.to_markup(res.to_s, options).html_safe
+    end
+    res.define_singleton_method :to_hashtag do
+      Hashtags::Builder.to_hashtag(res.to_s, options).html_safe
+    end
+    res
+  end
+
+  field.define_singleton_method :mongoize do |value|
+    Hashtags::Builder.to_hashtag(super(value.to_s), options)
+  end
+end