angular-rails4-templates 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a13f3844657fe44fd18eb117dec2521b80d0c6d0
+  data.tar.gz: 6e34a70494b8499ef5bdd483954edbcfc7018874
+SHA512:
+  metadata.gz: 2f1030c253b297758e529908c3b2deb19bb7766bc2950cea6e69d24f9d448dfa11e9ebf7987f562f11fd5cde913035cfe036c782a4597e6c63db65209620fa52
+  data.tar.gz: 40822030d06c66796e5e45f69dd9a85932cac9d704c77ca98e020a1e217231fc083ffc6519784ce65f09fcd9b0214d488d831b9f19190c4fa6daaebdf279df18

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Damien MATHIEU
+
+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,219 @@
+# Angular Rails4 Templates
+
+Adds your HTML templates into Angular's `$templateCache` using Rails asset pipeline. This gem is the updated version
+of https://github.com/pitr/angular-rails-templates that supports Sprockets3 and Rails4.
+
+It removes the need for AJAX calls to retrieve the templates (or for you to manually set them into the DOM).
+
+## Usage
+
+### 1. Add the Gem
+
+In Gemfile
+
+```ruby
+gem 'angular-rails4-templates'
+```
+
+### 2. Include Templates in Rails Asset Pipeline
+
+Then, in your `application.js` file, require `angular-rails-templates` and your templates:
+
+```javascript
+//= require angularjs
+// ...
+//= require angular-rails-templates
+//
+// Templates in app/assets/javascript/templates
+//= require_tree ./templates
+// OR
+// Templates in app/assets/templates (but see step 5)
+//= require_tree ../templates
+```
+
+Make sure to `require angular-rails-templates` **before** you require your templates.
+
+You'll need to use specific extensions to run the right preprocessor and load the resulting
+compiled template into the angular template cache.
+
+```
+foo.nghtml
+foo.html.nghaml
+foo.html.ngslim
+```
+Caution: *`.ngslim` is no longer supported!*
+
+Angular Rails Templates will try to load support for the following preprocessors if their gems are present:
+
+| Extension | Required gem                                             |
+|---------- |----------------------------------------------------------|
+| .nghaml   | haml                                                     |
+| .ngslim   | slim                                                     |
+
+See [Advanced](#advanced-configuration) if you would like to use other markup languages.
+
+### 3. Add a Dependency in your Angular Application Module
+
+Your Angular module needs to depend on the `templates` module. (configurable, see [Advanced Configuration](#configuration-option-module_name))
+
+```javascript
+angular.module('myApplication', ['templates']);
+```
+
+### 4. Use your Templates
+
+No matter what the source file extension is, your template's url will be  `#{base_name}.html`
+
+For example:
+```ruby
+main.nghtml => main.html
+widget.nghaml => widget.html
+```
+
+The templates can then be accessed via `templateUrl` as expected:
+
+```javascript
+// Template: app/assets/templates/yourTemplate.html.nghaml
+{
+  templateUrl: 'yourTemplate.html'
+}
+```
+
+Or anything else that uses `$templateCache` or `$templateRequest`
+
+```html
+<div ng-include='"yourTemplate.html"'></div>
+```
+
+### 5. Avoid name collisions
+
+If you have `app/assets/javascript/user.js` and `app/assets/templates/user.html`, the former one will actually hide the latter. This is due to how Rails asset pipeline sees asset files, both are served under `/assets/user.js`. Please use namespacing to combat this issue.
+
+## Advanced Configuration
+
+Angular Rails Templates has some configuration options that can be set inside `config/application.rb`
+
+Here are their default values:
+```ruby
+# config/application.rb
+config.angular_templates.module_name    = 'templates'
+config.angular_templates.ignore_prefix  = %w(templates/)
+config.angular_templates.inside_paths   = [Rails.root.join('app', 'assets')]
+config.angular_templates.markups        = %w(erb str haml slim md)
+config.angular_templates.htmlcompressor = false
+```
+
+### Configuration Option: `module_name`
+
+This configures the module name that your templates will be placed into.
+It is used to generate javascript like:
+
+```javascipt
+angular.module("<%= module_name %>")...
+```
+
+Although it is not recommended, you can set `module_name` to the name of your main application module and remove `require angular-rails-templates` from your javascript manifest to have your templates directly injected into your app.
+
+### Configuration Option: `ignore_prefix`
+
+*If you place your templates in `app/assets/templates` this option is mostly useless.*
+
+`ignore_prefix` will be stripped from the beginning of the `templateUrl` it reports to angularjs.
+
+Since the default ignore_prefix is [`templates/`], any templates placed under `app/assets/javascripts/templates` will automatically have short names. If your templates are not in this location, you will need to use the full path to the template.
+
+You can set `config.angular_templates.ignore_prefix` to change the default ignore prefix. Default is [`templates/`].
+
+
+``` javascript
+// Templates in: app/assets/javascripts/templates (default)
+// ignore_prefix: templates/ (default)
+{
+  templateUrl: 'yourTemplate.html'
+}
+// This won't work:
+{
+  templateUrl: 'templates/yourTemplate.html'
+}
+```
+
+``` javascript
+// Templates in: app/assets/javascripts/my_app/templates (custom)
+// ignore_prefix: templates/ (default)
+{
+  templateUrl: 'my_app/templates/yourTemplate.html'
+}
+
+// ignore_prefix: my_app/templates/ (custom)
+{
+  templateUrl: 'yourTemplate.html'
+}
+```
+
+
+### Configuration Option: `inside_paths`
+
+Templates only from paths matched by `inside_paths` will be used. By default anything under app/assets can be templates. This option is useful if you are using this gem inside an engine. Also useful if you DON'T want some files to be processed by this gem (see issue #88)
+
+
+### Configuration Option: `markups`
+
+Any markup that Tilt supports can be used, but you may need to add a gem to your Gemfile. See [Tilt](https://github.com/rtomayko/tilt) for a list of the supported markups and required libraries.
+
+```ruby
+# Gemfile
+gem "asciidoctor"
+gem "radius"
+gem "creole"
+gem "tilt-handlebars"
+
+# config/application.rb
+config.angular_templates.markups.push 'asciidoc', 'radius', 'wiki', 'hbs'
+```
+If you would like to use a non-standard extension or you would like to use a custom template, you just need to tell Tilt about it.
+
+```ruby
+# config/initializers/angular_rails_templates.rb
+Tilt.register Tilt::HamlTemplate, 'nghaml'
+
+# config/application.rb
+config.angular_templates.markups.push 'nghaml'
+```
+Note: You would still need to use `foo`**`.html`**`.nghaml`
+
+
+### Configuration Option: `htmlcompressor`
+
+The [htmlcompressor gem](https://github.com/paolochiodi/htmlcompressor) is in alpha, not activly maintained, and has several known bugs. Beware if you are using windows. The `simple_boolean_attributes` option is known to mangle angular templates. It depends on a three-year-old version of yui-compressor. However, it does a good job of compressing html!
+
+If you would like to use htmlcompressor add it to your Gemfile and Enable the configuration option.
+
+```ruby
+# Gemfile
+gem 'htmlcompressor'
+```
+
+```ruby
+# config/application.rb
+config.angular_templates.htmlcompressor = true
+```
+
+You can also pass an options hash to `htmlcompressor` that will be directly passed to ```HtmlCompressor::Compressor.new```. See the [ruby project](https://github.com/paolochiodi/htmlcompressor#usage) or the [java project](https://code.google.com/p/htmlcompressor/#Compressing_HTML_and_XML_files_from_a_command_line) for descriptions of the options.
+
+```ruby
+# config/application.rb
+config.angular_templates.htmlcompressor = {
+  :remove_quotes => true
+}
+```
+
+
+## License
+
+MIT License. Copyright 2014 Pitr
+
+## Authors & contributors
+
+* Damien Mathieu <42@dmathieu.com>
+* pitr <pitr.vern@gmail.com>
+* Jeremy Ebler <jebler@gmail.com>

data/lib/angular-rails-templates/compact_javascript_escape.rb

@@ -0,0 +1,29 @@
+module AngularRails4Templates
+  module CompactJavaScriptEscape
+    # inspired by Rails' action_view/helpers/javascript_helper.rb
+    JS_ESCAPE_MAP = {
+      '\\'    => '\\\\',
+      "\r\n"  => '\n',
+      "\n"    => '\n',
+      "\r"    => '\n',
+      '"'     => '\\"',
+      "'"     => "\\'"
+    }
+
+    # We want to deliver the shortist valid javascript escaped string
+    # Count the number of " vs '
+    # If more ', escape "
+    # If more ", escape '
+    # If equal, prefer to escape "
+
+    def escape_javascript(raw)
+      if raw
+        quote = raw.count(%{'}) >= raw.count(%{"}) ? %{"} : %{'}
+        escaped = raw.gsub(/(\\|\r\n|[\n\r#{quote}])/u) {|match| JS_ESCAPE_MAP[match] }
+        "#{quote}#{escaped}#{quote}"
+      else
+        '""'
+      end
+    end
+  end
+end

data/lib/angular-rails-templates/engine.rb

@@ -0,0 +1,78 @@
+require 'tilt'
+
+module AngularRails4Templates
+  class Engine < ::Rails::Engine
+    config.angular_templates = ActiveSupport::OrderedOptions.new
+    config.angular_templates.module_name    = 'templates'
+    config.angular_templates.ignore_prefix  = ['templates/']
+    config.angular_templates.inside_paths   = [] # defined in before_configuration
+    config.angular_templates.markups        = []
+    config.angular_templates.htmlcompressor = false
+
+    config.before_configuration do |app|
+      config.angular_templates.inside_paths = [Rails.root.join('app', 'assets')]
+
+      # try loading common markups
+      %w(erb haml liquid md radius slim str textile wiki).
+      each do |ext|
+        begin
+          silence_warnings do
+            config.angular_templates.markups << ext if Tilt[ext]
+          end
+        rescue LoadError
+          # They don't have the required library required. Oh well.
+        end
+      end
+    end
+
+
+    initializer 'angular-rails-templates', group: :all  do |app|
+      if app.config.assets
+        require 'sprockets'
+        require 'sprockets/engines' # load sprockets for Rails 3
+
+        # if app.config.angular_templates.htmlcompressor
+        #   require 'htmlcompressor/compressor'
+        #   unless app.config.angular_templates.htmlcompressor.is_a? Hash
+        #     app.config.angular_templates.htmlcompressor = {remove_intertag_spaces: true}
+        #   end
+        # end
+        #
+        # # These engines render markup as HTML
+        # app.config.angular_templates.markups.each do |ext|
+        #   # Processed haml/slim templates have a mime-type of text/html.
+        #   # If sprockets sees a `foo.html.haml` it will process the haml
+        #   # and stop, because the haml output is html. Our html engine won't get run.
+        #   mimeless_engine = Class.new(Tilt[ext]) do
+        #     def self.default_mime_type
+        #       nil
+        #     end
+        #   end
+        #
+        #   app.assets.register_engine ".#{ext}", mimeless_engine
+        # end
+
+        app.assets.register_mime_type 'text/ng-html', extensions: ['.nghtml']
+        app.assets.register_mime_type 'text/ng-haml', extensions: ['.nghaml']
+        app.assets.register_transformer 'text/ng-haml', 'application/javascript', AngularRails4Templates::HamlProcessor
+        app.assets.register_transformer 'text/ng-html', 'application/javascript', AngularRails4Templates::Processor
+      end
+
+      # Sprockets Cache Busting
+      # If ART's version or settings change, expire and recompile all assets
+      app.config.assets.version = [
+        app.config.assets.version,
+        'ART',
+        Digest::MD5.hexdigest("#{VERSION}-#{app.config.angular_templates}")
+      ].join '-'
+    end
+
+
+    config.after_initialize do |app|
+      # Ensure ignore_prefix can be passed as a String or Array
+      if app.config.angular_templates.ignore_prefix.is_a? String
+        app.config.angular_templates.ignore_prefix = Array(app.config.angular_templates.ignore_prefix)
+      end
+    end
+  end
+end

data/lib/angular-rails-templates/haml_processor.rb

@@ -0,0 +1,19 @@
+require 'angular-rails-templates/compact_javascript_escape'
+require 'haml'
+
+module AngularRails4Templates
+  class HamlProcessor < Processor
+
+    include CompactJavaScriptEscape
+
+    def render_html(input)
+      template = input[:data]
+      haml_engine = Haml::Engine.new(template)
+      output = haml_engine.render
+      escape_javascript output
+    rescue Haml::SyntaxError => ex
+      raise Haml::SyntaxError.new("#{input[:filename]} #{ex.message}", ex.line)
+    end
+
+  end
+end

data/lib/angular-rails-templates/javascript_template.js.erb

@@ -0,0 +1,6 @@
+// Angular Rails Template
+// source: <%= source_file %>
+
+angular.module("<%= angular_module %>").run(["$templateCache", function($templateCache) {
+  $templateCache.put("<%= angular_template_name %>", <%= html %>)
+}]);

data/lib/angular-rails-templates/processor.rb

@@ -0,0 +1,51 @@
+require 'angular-rails-templates/compact_javascript_escape'
+
+module AngularRails4Templates
+  class Processor
+
+    include CompactJavaScriptEscape
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key, :config
+
+    def config
+      Rails.configuration.angular_templates
+    end
+
+    def initialize(options = {})
+      @cache_key = [self.class.name, VERSION, options].freeze
+    end
+
+    def render_html(input)
+      escape_javascript input[:data].chomp
+    end
+
+    def template_name(name)
+      path = name.sub /^(#{config.ignore_prefix.join('|')})/, ''
+      "#{path}.html"
+    end
+
+    def call(input)
+      angular_template_name = template_name(input[:name])
+      angular_module = config.module_name
+      html = render_html(input)
+      source_file = "#{input[:filename]}".sub(/^#{Rails.root}\//,'')
+      erb = ERB.new(File.read("#{File.dirname __FILE__}/javascript_template.js.erb"))
+
+      result = erb.result binding
+
+      result
+    end
+  end
+end

data/lib/angular-rails-templates/template.rb

@@ -0,0 +1,53 @@
+require 'angular-rails-templates/compact_javascript_escape'
+
+module AngularRails4Templates
+  class Template < ::Tilt::Template
+    include CompactJavaScriptEscape
+    AngularJsTemplateWrapper = Tilt::ERBTemplate.new "#{File.dirname __FILE__}/javascript_template.js.erb"
+    @@compressor = nil
+
+    def self.default_mime_type
+      'application/javascript'
+    end
+
+    def prepare
+      # we only want to process html assets inside those specified in configuration.inside_paths
+      @asset_should_be_processed = configuration.inside_paths.any? { |folder| file.match(folder.to_s) }
+
+      if configuration.htmlcompressor and @asset_should_be_processed
+        @data = compress data
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      locals[:html] = escape_javascript data.chomp
+      locals[:angular_template_name] = logical_template_path(scope)
+      locals[:source_file] = "#{scope.pathname}".sub(/^#{Rails.root}\//,'')
+      locals[:angular_module] = configuration.module_name
+
+      if @asset_should_be_processed
+        AngularJsTemplateWrapper.render(scope, locals)
+      else
+        data
+      end
+    end
+
+    private
+
+    def logical_template_path(scope)
+      path = scope.logical_path.sub /^(#{configuration.ignore_prefix.join('|')})/, ''
+      "#{path}.html"
+    end
+
+    def configuration
+      ::Rails.configuration.angular_templates
+    end
+
+    def compress html
+      unless @@compressor
+        @@compressor = HtmlCompressor::Compressor.new configuration.htmlcompressor
+      end
+      @@compressor.compress(html)
+    end
+  end
+end