metaslug 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b1af058704bc625b6355a1c6ecf062f4d66e5bc
+  data.tar.gz: ce0ee9bb641e9f0a229bd9a417ab82768092d22c
+SHA512:
+  metadata.gz: 7d67b7081bade2b06be9c5dd3c30bdd2d55ec258b583a3b423fb83a4ac5fb3c293733f6d2ed6f530944598344b580fd3594500598ace30cda95ed751eadc5133
+  data.tar.gz: dd0dbfd64162c81889557a93c9365d4a4fe280f60589b19a66981567409960d8f0c18b6cf5a4384ed0d72cf74f9345becd9a49b0aff516615da49d44783246bc

data/.gitignore

@@ -0,0 +1,15 @@
+.bundle/
+.config
+.yardoc
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/db/*.sqlite3-journal
+test/dummy/log/*.log
+test/dummy/tmp/
+test/dummy/.sass-cache
+test/dummy/config/database.yml
+test/dummy/config/secrets.yml
+vendor/bundle
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in metaslug.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# Metaslug
+
+Metaslug allows you to map url to metas by locale.
+You can define slug '/awesome-page' will have title 'Awesome' with other custom metas.
+
+Metaslug uses liquid to be able to add dynamic content in the metas.
+
+## Starting
+
+First add the `metaslug` helper in your layout then use the install generator:
+
+~~~
+doctype html
+html lang="fr"
+  head
+    meta charset="utf-8"
+    = metaslug
+~~~
+
+~~~
+bundle exec rails generate metaslug:install
+~~~
+
+It will create the `config/metaslug` folder and add an initializer.
+Locale files should be presents in this directory, but there is a task to help you generating them using your defined routes.
+
+~~~
+bundle exec rails generate metaslug:locale
+~~~
+
+It will generate files like:
+
+~~~
+en:
+  default:
+    description: "Default description"
+    title: "Default title"
+  "/posts":
+    description: ""
+    title: ""
+  "/posts/:id/edit":
+    description: ""
+    title: ""
+~~~
+
+This generator takes options. For example:
+
+~~~
+bundle exec rails g metaslug:locale -l eueui -o -m description,keywords,title
+~~~
+
+will take generate a file for de locale. `-o` specifies to only print content on the console while `-m` takes your metas (defaults are title and description).
+
+On development mode, translations are reloaded for each request, not in the other environments.
+
+You can edit your locale file to add static or dynamic content.
+
+~~~
+en:
+  default:
+    description: "Default description"
+    title: "Default title"
+  "/my-page":
+    description: ""
+    title: "Title"
+  "/posts/:id/edit":
+    description: "Edit a post"
+    title: "Edit post with title {{post.title}}"
+~~~
+
+We use liquid templates to be able to add dynamic content, based on your vars.
+All you have to do is to allow methods in your model, and add allow variable in your controllers (they must be instance variable).
+`metaslug_vars` is just a before_filter and can take the exact same options, like only, except…
+
+~~~
+class Post < ActiveRecord::Base
+  liquid_methods :title
+end
+~~~
+
+~~~
+class PostsController < ApplicationController
+  before_action :set_post, only: [:show, :edit, :update, :destroy]
+  metaslug_vars :post, only: :edit
+
+  private
+    def set_post
+      @post = Post.find(params[:id])
+    end
+end
+~~~
+
+## Tests
+
+You can run the integration tests using:
+
+~~~
+bundle exec rake test
+~~~
+
+## Warning
+
+Metaslug overrides the default render method, to be able to use dynamic metas.
+We need to access the vars setted after action and interpolate them before rendering.
+
+## Roadmap
+
+This is what we planned to add next:
+
+- Different storage (database, cache…)
+- Web interface to edit metas from the app
+- Remove rails dependency

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/metaslug/controllers/action_controller_extension.rb

@@ -0,0 +1,165 @@
+module Metaslug
+  module ActionControllerExtension
+    extend ActiveSupport::Concern
+    included do
+
+      #
+      # Initialise the traduction hash, load every metas into it.
+      # We only do this once, unless it is the development environment.
+      #
+      # @return [void] [Load metas of the current page]
+      def load_metas_for_current_slug
+        # initialize storage to an empty Hash, unless already exists
+        initialize_metas_storage
+        load_all_metas if Rails.env.development? or metas_storage.empty?
+        set_metas_for_current_path
+      end
+
+      #
+      # A locale corresponds to a YAML file. We load each YAML file individually
+      # then merge then into a global hash.
+      #
+      # @return [Hash] [Global hash with all metas]
+      def load_all_metas
+        Thread.current[:metas] = I18n.available_locales.inject({}) do |acc, locale|
+          acc.merge!(load_metas_for_locale(locale))
+          acc
+        end
+      end
+
+      #
+      # Load a YAML file corresponding to a locale after ensuring it exists.
+      # @param locale [Symbol] [Locale]
+      #
+      # @return [Hash] [Metas]
+      def load_metas_for_locale(locale)
+        path = metas_path(locale)
+        if File.exists?(path)
+          YAML.load(File.open(path))
+        else
+          logger.error "[Metaslug] #{path} not found."
+          {}
+        end
+      end
+
+      #
+      # Search and load metas of the current path.
+      #
+      # @return [void]
+      def set_metas_for_current_path
+        locale_metas_storage.keys.each do |k|
+          if request.path.match(translate_key_into_regexp(k))
+            set_metas_from_hash(locale_metas_storage[k])
+            return
+          end
+        end
+
+        # if no key match the current path, load default metas if present.
+        if locale_metas_storage.has_key?('default')
+          set_metas_from_hash(locale_metas_storage['default'])
+        else
+          set_metas_from_hash({})
+        end
+      end
+
+      #
+      # Load metas into an instance variable to have access to them in the helper.
+      # Get the instance variables mark as accessible in the before_filter to interpolate
+      # values in the liquid template.
+      # @param values [Hash] [Metas]
+      #
+      # @return [Hash] [Metas]
+      def set_metas_from_hash(values)
+        @metaslug_vars ||= []
+        # For each meta we need to interpole the value if it use a dynamic content.
+        values.each do |k ,v|
+          if v.is_a?(Hash)
+            # recursive call for nested hash like { 'og' => { 'locale' => { 'alternate' => 'fr_FR' } } }
+            set_metas_from_hash(v)
+          else
+            # Looks like a liquid template
+            if v =~ /{{.*}}/
+              if @metaslug_vars.empty?
+                Rails.logger.debug "You provide a template but don't set access to your vars in the associated controller."
+                values[k] = v
+              else
+                template  = Liquid::Template.parse(v)
+                h = @metaslug_vars.inject({}) do |acc, v|
+                  acc[v.to_s] = instance_variable_get("@#{v}")
+                  acc
+                end
+                values[k] = template.render(h)
+              end
+            end
+          end
+        end
+        @metaslug = values
+      end
+
+      #
+      # Return path of the YAML file of this locale.
+      # @param locale [Symbol] [Locale]
+      #
+      # @return [Pathname] [Path of the YAML file]
+      def metas_path(locale)
+        # TODO: Let user configure it.
+        Rails.root.join('config', 'metaslug', "#{locale}.yml")
+      end
+
+      #
+      # Metas of the given locale
+      # @param locale = I18n.locale [Symbol] [Locale]
+      #
+      # @return [Hash] [Metas]
+      def locale_metas_storage(locale = I18n.locale)
+        metas_storage[I18n.locale.to_s]
+      end
+
+      #
+      # Backend storage of the metas. We store it in the current thread to avoid
+      # reloading it.
+      #
+      # @return [Hash] [Global metas]
+      def metas_storage
+        Thread.current[:metas]
+      end
+
+      #
+      # Initialize storage to an empty hash, unless already set.
+      #
+      # @return [Hash] [Global metas]
+      def initialize_metas_storage
+        Thread.current[:metas] ||= {}
+      end
+
+      #
+      # YAML entries may looks like routes, like /categories/:id/edit. To be able
+      # to test these entries, we convert them to regexp, replacing :id (and others sym)
+      # @param k [String] [key]
+      #
+      # @return [Regexp] [Builded regexp]
+      def translate_key_into_regexp(k)
+        # replace :id with regular expression
+        %r{^#{k.gsub /\:\w+/, '[a-z0-9_.-]+'}$}i
+      end
+
+      def self.metaslug_vars(*args)
+        before_filter args.extract_options! do
+          @metaslug_vars = args
+        end
+      end
+
+      #
+      # Overriding the default render method because we need to use the action
+      # variables to render the liquid template. This had to be done after the
+      # action and before the render.
+      # @param *args [Array] [Default arguments]
+      #
+      # @return [type] [description]
+      def render(*args)
+        load_metas_for_current_slug
+        super
+      end
+    end
+  end
+end

data/lib/metaslug/helpers/action_view_extension.rb

@@ -0,0 +1,49 @@
+module Metaslug
+  module ActionViewExtension
+    def metaslug
+      @metaslug.inject([]) do |acc, (k, v)|
+        if 'title' == k.to_s
+          acc << content_tag(:title, @metaslug['title'])
+        elsif v.is_a?(Hash)
+          # more complicated metas, like property
+          set_metas_from_hash(v, k, acc)
+        else
+          acc << content_tag(:meta, nil, { name: k.to_s, content: @metaslug[k.to_s] })
+        end
+        acc
+      end.join.html_safe
+    end
+
+    private
+      #
+      # Recursive function to build metas and add them to the accumulator.
+      # @param hash [Hash] [Hash of the metas]
+      # @param key [String] [Key of the parent hash]
+      # @param acc [Array] [Metas accumulator]
+      # @param separator = ':' [String] [Separator used when building key, ex: og:title]
+      #
+      # @return [type] [description]
+      def set_metas_from_hash(hash, key, acc, separator = ':')
+        hash.each do |k, v|
+          if v.is_a?(Hash)
+            _k = build_meta_name(key, k, separator)
+            set_metas_from_hash(v, _k, acc)
+          else
+            _k = build_meta_name(key, k, separator)
+            acc << content_tag(:meta, nil, { property: _k, content: v })
+          end
+        end
+      end
+
+      #
+      # Construct meta name based on the previous keys
+      # @param base_key [String] [Key of the parent hash, ex: og]
+      # @param key [String] [Key of the actual hash, ex: title]
+      # @param separator = ':' [String] [Separator used when building key, ex: og:title]
+      #
+      # @return [type] [description]
+      def build_meta_name(base_key, key, separator = ':')
+        base_key.present? ? "#{base_key}#{separator}#{key}" : key
+      end
+  end
+end

data/lib/metaslug/hooks.rb

@@ -0,0 +1,15 @@
+module Metaslug
+  class Hooks
+    def self.init
+      ActiveSupport.on_load(:action_controller) do
+        require 'metaslug/controllers/action_controller_extension'
+        ::ActionController::Base.send :include, Metaslug::ActionControllerExtension
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        require 'metaslug/helpers/action_view_extension'
+        ::ActionView::Base.send :include, Metaslug::ActionViewExtension
+      end
+    end
+  end
+end

data/lib/metaslug/railtie.rb

@@ -0,0 +1,7 @@
+module Kaminari
+  class Railtie < ::Rails::Railtie
+    initializer 'metaslug' do |app|
+      Metaslug::Hooks.init
+    end
+  end
+end

data/lib/metaslug/version.rb

@@ -0,0 +1,3 @@
+module Metaslug
+  VERSION = "0.3.3"
+end

data/lib/metaslug.rb

@@ -0,0 +1,7 @@
+module Metaslug
+end
+
+# metaslug components
+require 'metaslug/hooks'
+
+require 'metaslug/railtie.rb' if defined?(Rails)

data/lib/rails/generators/metaslug/install/install_generator.rb

@@ -0,0 +1,21 @@
+module Metaslug
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      def self.banner
+        <<-BANNER.chomp
+rails generate metaslug:install
+
+Create locale's folder and initializer.
+BANNER
+      end
+
+      def create_locales_folder
+        empty_directory "config/metaslug"
+      end
+
+      def generate_install_file
+        create_file "config/initializers/metaslug.rb", "require 'liquid'"
+      end
+    end
+  end
+end

data/lib/rails/generators/metaslug/locale/locale_generator.rb

@@ -0,0 +1,69 @@
+module Metaslug
+  module Generators
+    class LocaleGenerator < Rails::Generators::Base
+      class_option :locale, type: :string, aliases: '-l', desc: "Generate a locale file base on the routes."
+      class_option :output, type: :string, aliases: '-o', desc: "Do not create file, just output buffer."
+      class_option :metas, type: :string, aliases: '-m', desc: "Define the metas you want to use."
+
+      def self.banner
+        <<-BANNER.chomp
+rails generate metaslug:locale
+
+Try to generate the metas file of the given locale, based on the current routes.
+BANNER
+      end
+
+      def generate_locale_file
+        routes = get_paths_from_routes
+
+        locales = options.locale? ?
+          [options.locale] :
+          I18n.available_locales
+
+        metas = options.metas? ?
+          options.metas.split(',') :
+          ["description", "title"]
+
+        locales.each do |locale|
+          buffer = "#{locale}:\n"
+          add_metas_to_buffer(buffer, 'default', { quote_section: false }, *metas)
+
+          routes.each do |route|
+            add_metas_to_buffer(buffer, route, { quote_section: true }, *metas)
+          end
+
+          if options.output?
+            $stdout.puts buffer
+          else
+            create_file "config/metaslug/#{locale}.yml", buffer
+          end
+        end
+      end
+
+      private
+        def add_metas_to_buffer(buffer, section, options = {}, *args)
+          spaces = ' ' * 2
+          if options[:quote_section]
+            buffer << "#{spaces}\"#{section}\":\n"
+          else
+            buffer << "#{spaces}#{section}:\n"
+          end
+
+          args.each do |meta|
+            buffer << "#{spaces * 2}\"#{meta}\": \"\"\n"
+          end
+        end
+
+        def get_paths_from_routes
+          Rails.application.routes.routes.map do |route|
+            path = route.path.spec.to_s
+            # only keep GET url
+            next unless "GET".match route.verb.to_s
+            next if path.starts_with?('/assets') or path.starts_with?('/rails')
+            # remove (.:format), this is a bit dirty
+            $1 if path.match /(.*)\(.*/
+          end.compact.uniq
+        end
+    end
+  end
+end

data/lib/tasks/metaslug_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :metaslug do
+#   # Task goes here
+# end

data/metaslug.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "metaslug/version"
+
+Gem::Specification.new do |s|
+  s.name        = "metaslug"
+  s.version     = Metaslug::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Martin Catty"]
+  s.email       = ["mcatty@synbioz.com"]
+  s.homepage    = "https://github.com/synbioz/metaslug"
+  s.summary     = "Set metas according to a path."
+  s.description = "Metaslug allows you to set your metas information in a localized YAML file."
+  s.license     = "MIT"
+
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.add_dependency "rails", "~> 4.0"
+  s.add_dependency "liquid"
+
+  s.add_development_dependency "capybara"
+  s.add_development_dependency "sqlite3"
+end

data/test/dummy/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__)
+
+Rails.application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/test/dummy/app/assets/stylesheets/scaffold.css

@@ -0,0 +1,56 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+div.field, div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  margin-bottom: 0px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,13 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+  prepend_before_filter :set_locale
+
+  private
+    def set_locale
+      if I18n.available_locales.map(&:to_s).include?(params[:locale])
+        I18n.locale = params[:locale]
+      end
+    end
+end