crystalmeta 0.9.0

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle/
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opengraphy.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,130 @@
+PATH
+  remote: .
+  specs:
+    crystalmeta (0.9.0)
+      rails (>= 3.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.2.9)
+      actionpack (= 3.2.9)
+      mail (~> 2.4.4)
+    actionpack (3.2.9)
+      activemodel (= 3.2.9)
+      activesupport (= 3.2.9)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.9)
+      activesupport (= 3.2.9)
+      builder (~> 3.0.0)
+    activerecord (3.2.9)
+      activemodel (= 3.2.9)
+      activesupport (= 3.2.9)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.9)
+      activemodel (= 3.2.9)
+      activesupport (= 3.2.9)
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.3.2)
+    arel (3.0.2)
+    builder (3.0.4)
+    capybara (2.0.1)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.3.3)
+      rack (>= 1.0.0)
+      rack-test (>= 0.5.4)
+      selenium-webdriver (~> 2.0)
+      xpath (~> 1.0.0)
+    childprocess (0.3.6)
+      ffi (~> 1.0, >= 1.0.6)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    ffi (1.2.0)
+    hike (1.2.1)
+    i18n (0.6.1)
+    journey (1.0.4)
+    json (1.7.5)
+    libwebsocket (0.1.7.1)
+      addressable
+      websocket
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.5.0)
+    nokogiri (1.5.6)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.9)
+      actionmailer (= 3.2.9)
+      actionpack (= 3.2.9)
+      activerecord (= 3.2.9)
+      activeresource (= 3.2.9)
+      activesupport (= 3.2.9)
+      bundler (~> 1.0)
+      railties (= 3.2.9)
+    railties (3.2.9)
+      actionpack (= 3.2.9)
+      activesupport (= 3.2.9)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.0.3)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+    rspec-rails (2.12.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rubyzip (0.9.9)
+    selenium-webdriver (2.27.2)
+      childprocess (>= 0.2.5)
+      libwebsocket (~> 0.1.3)
+      multi_json (~> 1.0)
+      rubyzip
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.12)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.35)
+    websocket (1.0.6)
+    xpath (1.0.0)
+      nokogiri (~> 1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  capybara (~> 2.0.1)
+  crystalmeta!
+  rspec-rails (~> 2.12)

data/Rakefile

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

data/Readme.markdown

@@ -0,0 +1,210 @@
+**Crystalmeta helps you control meta tags through I18n and/or manually. It plays well with [OpenGraph](http://ogp.me/).**
+
+It gives you 3 helpers:
+
+**1.** `meta(options)` — available in both controller & views.
+
+Accepts `Hash`.
+
+Collects meta tags for future use:
+
+```ruby
+# folded hashes
+meta og: {title: "The Rock (1996)", type: "video.movie"}
+
+# one level hash
+meta "og:title" => "The Rock (1996)", "og:type" => "video.movie"
+meta :"og:image" => "the-rock.png"
+```
+
+**2.** `meta_tag(name)` — available in views
+
+Accepts `String` or `Symbol`.
+
+Returns value for a certain tag:
+
+```erb
+<title><%= meta_tag 'og:title' %></title>
+```
+
+**3.** `meta_tags(pattern = //)`
+
+Returns all meta tags which names match the pattern. Under the hoods it uses the three-qual to pattern match (like in `Enumerable#grep`).
+
+```erb
+<%= meta_tags %>
+```
+
+displays in this case:
+
+```html
+<meta property="og:url" content="http://www.imdb.com/title/tt0117500/" />
+<meta property="og:image" content="/assets/the-rock.png" />
+<meta property="og:title" content="The Rock (1996)" />
+<meta property="og:type" content="video.movie" />
+```
+
+Please note that: 
+
+* `image_path` is automatically used for `og:image` or `og:image:url` (`video_path` for `og:video` and `audio_path` for `og:audio` respectively), so you don't have to bother setting explicit paths;
+* `og:url` is set to `controller.request.url`.
+
+## I18n translations
+
+Crystalmeta tries to fetch translations and merge them in this order (consider an example for `pages#show` action):
+
+* `meta._defaults` — application defaults (lowest-priority)
+* `meta.pages._defaults` — controller defaults
+* `meta.pages.show` — action
+
+Tags set manually by the `meta` helper will be given the highest priority.
+
+**Namespaced controllers**
+
+Crystalmeta uses `controller_path` in order to get the translation scope, so if you have a namespaced controller, for instance `Library::BooksController`, then the `show` action will use: `meta.library.books._defaults` & `meta.library.books.show` respectively.
+
+**Aliases**
+
+Crystalmeta uses translations for the `edit` action for `update`:
+
+* `meta._defaults`
+* `meta.movies._defaults`
+* `meta.movies.edit`
+* `meta.movies.update`
+
+And `new` for `create`:
+
+* `meta._defaults`
+* `meta.movies._defaults`
+* `meta.movies.new`
+* `meta.movies.create`
+
+You can omit defining translations for `update` & `create` actions if they're the same.
+
+## Displaying only certain meta tags using a pattern
+
+Usually I set window title with Crystalmeta separately (I call it `head` for example) and I don't want to display it in meta tags, so I can do:
+
+```erb
+<%= meta_tags /:/ %>
+```
+
+It will filter tag names using `/:/ === name`.
+
+You may wish to use a `Proc` in some cases:
+
+```erb
+<%= meta_tags Proc.new{|name| name != "head"} %>
+```
+
+## Interpolation
+
+You can interpolate meta tags like this:
+
+```erb
+<% meta({
+  "og:title"     => "The Rock (1996)",
+  "og:site_name" => "IMDb",
+  "head"         => "%{og:title} — %{og:site_name}"
+}) %>
+```
+
+`meta_tag :head` will return `"The Rock (1996) — IMDb"`.
+
+Please use this feature with care to avoid [SystemStackError](http://ruby-doc.org/core-1.9.3/SystemStackError.html).
+
+## Caveats
+
+**Merging tags**
+
+When tags are merged (while fetching translations or collecting with `meta`) Crystalmeta doesn't do anything smart — it just merges hashes brutally. So if you defined a tag like that:
+
+```yml
+en:
+  meta:
+    _defaults:
+      og:
+        title: IMDb
+```
+
+and then you redefine it in different style:
+
+```ruby
+meta 'og:title' => 'The Rock (1996)'
+```
+
+then you'll just get 2 tags in the end:
+
+```erb
+<%= meta_tags /og:title/ %>
+```
+
+will display
+
+```html
+<meta property="og:title" content="IMDb" />
+<meta property="og:title" content="Newer IMDb" />
+```
+
+So you'd better prefer one style.
+
+**Date/Time**
+
+Crystalmeta will convert Date/Time/Datetime objects to [iso8601](http://en.wikipedia.org/wiki/ISO_8601) automatically, so if you don't want it, pass them as strings.
+
+**Arrays**
+
+To maximize [OpenGraph](http://ogp.me/#array) compatibility, Crystalmeta handles Arrays in similar way:
+
+```erb
+<% meta :og => {:image => %w{1.png 2.png}} %>
+<%= meta_tags /og:image/ %>
+```
+
+will display:
+
+```html
+<meta property="og:image" content="/assets/1.png" />
+<meta property="og:image" content="/assets/2.png" />
+```
+
+**Multiple images with properties**
+
+If you have multiple images with properties like this:
+
+```html
+<meta property="og:image:url" content="/assets/rock.jpg" />
+<meta property="og:image:width" content="300" />
+<meta property="og:image:height" content="300" />
+<meta property="og:image:url" content="/assets/rock2.jpg" />
+<meta property="og:image:url" content="/assets/rock3.jpg" />
+<meta property="og:image:height" content="1000" />
+```
+
+then you'll have to set them in a special way:
+
+```erb
+<% meta 'og:image' => [
+  {:url => 'rock.jpg', :width => 300, :height => 300},
+  {:url => 'rock2.jpg'},
+  {:url => 'rock3.jpg', :height => 1000},
+] %>
+```
+
+or:
+
+```yml
+en:
+  meta:
+    pages:
+      show:
+        og:image:
+          - url: rock.jpg
+            width: 300
+            height: 300
+          - url: rock2.jpg
+          - url: rock3.jpg
+            height: 1000
+```
+
+It will sort keys so that the `url` property is on top.

data/crystalmeta.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crystal/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "crystalmeta"
+  gem.version       = Crystal::VERSION
+  gem.authors       = ["Max Savchenko"]
+  gem.email         = ["robotector@gmail.com"]
+  gem.description   = %q{Crystal clean meta tags for Rails applications. Support I18n. Perfect for OpenGraph.}
+  gem.summary       = %q{Crystalmeta helps you control meta tags through I18n and/or manually. It plays well with OpenGraph.}
+  gem.homepage      = "http://github.com/macovsky/crystalmeta"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency("rails", ">= 3.0.0")
+  gem.add_development_dependency 'rspec-rails', '~> 2.12'
+  gem.add_development_dependency 'capybara', '~> 2.0.1'
+end

data/lib/crystal/controller_extensions.rb

@@ -0,0 +1,19 @@
+module Crystal
+  module ControllerExtensions
+    def self.included(base)
+      base.before_filter :_set_meta
+      base.helper_method :meta
+    end
+
+    def meta(options = {})
+      options.present? && @_meta.store(options)
+      @_meta
+    end
+
+    protected
+
+    def _set_meta
+      @_meta = Meta.new(OptionsForController.new(self).options)
+    end
+  end
+end

data/lib/crystal/hash_with_stringify_keys.rb

@@ -0,0 +1,52 @@
+module Crystal
+  class HashWithStringifyKeys < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor).stringify_keys!
+      else
+        super(constructor)
+      end
+    end
+
+    # https://github.com/intridea/hashie/blob/master/lib/hashie/extensions/key_conversion.rb
+
+    # Convert all keys in the hash to strings.
+    # @example
+    #   test = {:abc => 'def'}
+    #   test.stringify_keys!
+    #   test # => {'abc' => 'def'}
+    def stringify_keys!
+      keys.each do |k|
+        stringify_keys_recursively!(self[k])
+        self[k.to_s] = self.delete(k)
+      end
+      self
+    end
+
+    # Return a new hash with all keys converted
+    # to strings.
+    def stringify_keys
+      dup.stringify_keys!
+    end
+
+    protected
+
+    # Stringify all keys recursively within nested
+    # hashes and arrays.
+    def stringify_keys_recursively!(object)
+      if self.class === object
+        object.stringify_keys!
+      elsif ::Array === object
+        object.each do |i|
+          stringify_keys_recursively!(i)
+        end
+        object
+      elsif object.respond_to?(:stringify_keys!)
+        object.stringify_keys!
+      else
+        object
+      end
+    end
+  end
+end