js-flasher 0.2.2

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2012 Joseph Smith
+
+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,171 @@
+js-flasher
+==========
+
+A simple gem that exposes unprocessed JS templates.
+
+`js-flasher`, as the name loosely suggests, exposes something. At its core, it will take files, and build Javascript objects keyed by filename, where the contents of the file are the values. It can run happily alongside, but is not dependent on, Sprockets.
+
+###### Why would I use this over other solutions like Sprockets JST templates?
+
+Since `js-flasher` passes around an object packed with your markup, rather than template functions, you are free to pass many templates, without fear that you generating large objects of precompiled template functions. This approach has bonuses as well as drawbacks.
+
+Bonuses
+
+- less data is being passed around than say, Sprockets' templates, therefore actual JS payload can be much smaller
+- you are given full flexiblity to handle rendering your templates however you see fit
+
+Drawbacks
+
+- more client-side processing as you compile/render your templates at runtime or JS app bootstrap.
+
+If you have read the above and feel like `js-flasher` is a good fit for your project, continue on.
+
+
+## Installation:
+
+If you're using Bundler, this will get you up and running 
+
+    gem 'js-flasher', :git => 'git://github.com/technicolorenvy/js-flasher.git'
+
+
+or, for non-Bundler-users 
+
+    git clone git://github.com/technicolorenvy/js-flasher.git 
+    cd js-flasher
+    gem build js-flasher.gemspec
+    gem install js-flasher-VERSION.gem
+
+NOTE: The only dependency this gem has is the `json` gem, which is likely already installed for most users
+
+### Default Config
+
+`js-flasher` ships with some (hopefully) smart defaults. These are largely geared towards a vanilla Rails 3.1 (or higher) environment, but are easily be overridden.
+
+##### Template Sources
+
+Hash of template sources arranged as 'Target Object' => 'Source Directory'
+
+    :template_sources = {:Templates => 'app/assets/templates'}
+
+
+##### Supported Extensions
+
+Array of file endings
+
+    :supported_extensions = ['.tpl.html']
+
+##### Target Directory
+
+String representation of your target directory
+
+    :target_directory = 'app/assets/javascripts/templates'
+
+##### JS Namespace
+
+Parent Javascript object generated for namespacing
+
+    :js_namespace = 'JSF'
+
+##### Extensions in Keys
+
+Shoud the resulting JS object include file extensions in it's keys?
+
+    :extensions_in_keys = false
+
+## Usage - Rails:
+
+#### Config
+
+The recommended process for modifying `js-flasher` configuration in Rails is
+
+- Add an initializer to `conf/initializers/` named `js-flasher.rb`
+- Apply configuration changes via a do block 
+
+		JsFlasher::configure do |c|
+			c.template_sources = {:Shared => 'app/assets/templates', :Web => 'app/assets/app/web/'}
+			c.supported_extensions = ['.my.extension1', '.extension2', '.etc']
+		end
+
+
+#### Create files
+
+You can create files for your JS template objects by running `rake js_flasher:build_files`. This will create a file for each template source that you have passed in.
+
+For example, given the above configure block, we would create two files in our `app/assets/javascripts/templates` directory (our default target directory). `Shared.js.erb` and `Web.js.erb`. Each file will have only its set of templates.
+
+The contents of the generated `Shared.js.erb` would look something like the following.
+
+    var JSF = JSF || {}; JSF.Shared = <%= JsFlasher.get_templates([:Shared]) %>;
+
+In this case our namespace `JSF` is also generated from our default config and may be overridden
+
+
+#### Access your templates
+
+Now in your Javascript files you are free to use whatever templating system you want. You may access your template like so.
+
+    JSF.Shared['path/to/my/template']
+
+Paths are relative to your template set. In other words, in the above example your template would actually live in `app/assets/templates/path/to/my/template`.
+
+## Usage - Non Rails 
+(or for those who prefer greater flexibility):
+
+`js-flasher` comes with an instantiatable class called `JsFlasherInitable`.
+
+#### Create + Config
+
+- Instantiate your object, passing in your config 
+
+        js_flasher = JsFlasherInitable.new({
+            :template_sources => {
+                :Shared => 'app/assets/templates', 
+                :Web => 'app/assets/app/web/'
+            }
+        })
+
+
+#### Expose templates
+
+It's recommended that you do this through a `.js.erb` file. This way, in production, you can take advantage of cacheing, assuming you are precompiling your assets. Something like `templates.js.erb` seems nice and self-documenting.
+
+Assuming you want All of your templates, you could create a file whose contents look like.
+
+    # contents of templates.js.erb
+    <% js_flasher = JsFlasherInitable.new({
+            :template_sources => {
+                :Shared => 'app/assets/templates', 
+                :Web => 'app/assets/app/web/'
+            }
+        })
+    %>
+    window.Shared = <%= js_flasher.get_templates %>;
+
+If you have multiple template sets and you prefer breaking the generated template strings into multiple files you could split them like so
+
+shared.js.erb
+
+    # contents of shared.js.erb
+    <% shared_emplates = JsFlasherInitable.new({
+            :template_sources => {
+                :Shared => 'app/assets/templates', 
+            }
+        })
+    %>
+    window.Shared = <%= shared_templates.get_templates %>;
+
+web.js.erb
+
+    # contents of web.js.erb
+    <% web_templates = JsFlasherInitable.new({
+            :template_sources => {
+                :Web => 'app/assets/app/web/'
+            }
+        })
+    %>
+    window.webTemplates = <%= web_templates.get_templates %>;
+
+Using the above described methods, you can skip using `js-flasher`s `:target_directory` and `:js_namespace` options as they are mostly used for file generation in the included Rails specific Rake task.
+
+
+

data/js-flasher.gemspec

@@ -0,0 +1,18 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "js_flasher/version"
+
+Gem::Specification.new do |s|
+  s.name          = "js-flasher"
+  s.version       = JsFlasher::VERSION
+  s.authors       = ["Jos Smith"]
+  s.email         = ["technicolorenvy@gmail.com"]
+  s.homepage      = "https://github.com/technicolorenvy/js-flasher"
+  s.summary       = "A simple gem that exposes unprocessed JS templates"
+  s.description   = "A simple gem that exposes unprocessed JS templates"
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'json'
+ 
+end

data/lib/js-flasher.rb

@@ -0,0 +1,24 @@
+require 'js_flasher/version'
+require 'js_flasher/configuration'
+require 'js_flasher/get_templates'
+
+module JsFlasher
+  extend Configuration
+  extend GetTemplates
+  require 'js_flasher/railtie' if defined?(Rails)
+end
+
+class JsFlasherInitable
+  # include JsFlasher
+  include JsFlasher::Configuration
+  include JsFlasher::GetTemplates
+
+  def initialize(config = {})
+    reset()
+
+    config.each do |opt, val|
+      self.send("#{opt}=",val)
+    end
+  end
+
+end

data/lib/js_flasher/configuration.rb

@@ -0,0 +1,46 @@
+module JsFlasher
+
+  module Configuration
+
+    VALID_OPTIONS = [
+      :template_sources,
+      :supported_extensions,
+      :target_directory,
+      :js_namespace,
+      :extensions_in_keys
+    ]
+
+    VALID_OPTIONS.each { |opt| attr_accessor opt }
+
+    DEFAULT_TEMPLATE_SOURCES = {:Templates => 'app/assets/templates'}
+
+    DEFAULT_SUPPORTED_EXENSIONS = ['.tpl.html']
+
+    DEFAULT_TARGET_DIRECTORY = 'app/assets/javascripts/templates'
+
+    DEFAULT_JS_NAMESPACE = 'JSF'
+
+    DEFAULT_EXTENSIONS_IN_KEYS = false
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # assign our defaults
+    def reset
+      self.template_sources       = DEFAULT_TEMPLATE_SOURCES
+      self.supported_extensions   = DEFAULT_SUPPORTED_EXENSIONS
+      self.target_directory       = DEFAULT_TARGET_DIRECTORY
+      self.js_namespace           = DEFAULT_JS_NAMESPACE
+      self.extensions_in_keys     = DEFAULT_EXTENSIONS_IN_KEYS
+    end
+
+  end
+
+end

data/lib/js_flasher/get_templates.rb

@@ -0,0 +1,47 @@
+require 'json'
+
+module JsFlasher
+  module GetTemplates
+
+    def get_templates_ob(subset = nil)
+
+      subset ||= self.template_sources.keys
+      templates_ob   = {}
+
+      self.template_sources.each do |tpl_name, tpl_dir|
+
+        if subset && subset.include?(tpl_name)
+          templates_ob[tpl_name] = {}
+
+          Dir.chdir(tpl_dir) do 
+            outs = Dir.glob("**/*")
+
+            outs.each do |filename|
+              out_arr = filename.split('/').last.split('.')
+              out_arr.shift
+              extension = ".#{out_arr.join('.')}"
+              filename_key = (self.extensions_in_keys) ? filename : filename.gsub(extension, '')
+
+              if self.supported_extensions.include? extension
+                filecontents = File.open(filename, "rb") { |f| f.read }
+                templates_ob[tpl_name][filename_key] = filecontents.gsub(/([\n\t\r])/, '')
+              end
+            end
+          end
+
+        end
+      end
+
+      if subset.length === 1
+        templates_ob = templates_ob[subset[0].to_sym]
+      end
+
+      return templates_ob
+    end
+
+    def get_templates(subset = nil)
+      templates = get_templates_ob(subset).to_json
+    end
+
+  end
+end

data/lib/js_flasher/railtie.rb

@@ -0,0 +1,8 @@
+require 'rails'
+module JsFlasher
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/js-flasher.rake'
+    end
+  end
+end

data/lib/js_flasher/version.rb

@@ -0,0 +1,4 @@
+module JsFlasher
+  # shit's in beta, son
+  VERSION = "0.2.2"
+end

data/lib/tasks/js-flasher.rake

@@ -0,0 +1,21 @@
+namespace :js_flasher do
+    desc ""
+    task :build_files => :environment do
+        templates_object    = JsFlasher::get_templates_ob
+        target_directory    = JsFlasher::target_directory
+        js_namespace        = JsFlasher::js_namespace
+
+        templates_object.each do |ob_name, templates|
+            out = "var #{js_namespace} = #{js_namespace} || {}; "
+
+            out << "#{js_namespace}.#{ob_name} = "
+            out << "<%= JsFlasher.get_templates([:#{ob_name}]) %>;"
+
+            FileUtils.mkdir_p(target_directory)
+
+            File.open("#{target_directory}/#{ob_name}.js.erb", 'w') {|f| f.write(out) }
+        end
+
+    end
+    
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: js-flasher
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+  prerelease: 
+platform: ruby
+authors:
+- Jos Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple gem that exposes unprocessed JS templates
+email:
+- technicolorenvy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- js-flasher.gemspec
+- lib/js-flasher.rb
+- lib/js_flasher/configuration.rb
+- lib/js_flasher/get_templates.rb
+- lib/js_flasher/railtie.rb
+- lib/js_flasher/version.rb
+- lib/tasks/js-flasher.rake
+homepage: https://github.com/technicolorenvy/js-flasher
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A simple gem that exposes unprocessed JS templates
+test_files: []