json2html-rails 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3abc1d6b0c26aaee21b92b649896a5c55c996d36
+  data.tar.gz: 5fa3163a94ace452509f89a1154715aee57ec7af
+SHA512:
+  metadata.gz: d91ef05505a10cdc15193af5ccc0408fb661cc4e89528cd4072c88d718a2e3cd528d291f33e9dc4bb6b1d783979bec5c80b0ee62cee6e626bdd5aef84346e45f
+  data.tar.gz: 5f6efced69443441201a82dcdf9a5f5b19c5a58573b578f259dac215ba9371f3df9e776b6d3b05f9c9a3e7bbd223dd2dbd96043a53837deebd5d127ca4682c3b

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+idea/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 rubyrider
+
+MIT License
+
+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,54 @@
+# Json2html::Rails
+
+
+Instead of writing HTML templates json2html relies on JSON transforms to convert a source JSON objects to html. The benefit of using a JSON transform is that they are already readable by the browser and DO NOT require any compilation before use. In addition, json2html allows the following
+
+Short hand notation for mapping data objects to markup
+Event binding to DOM objects (exclusively with jquery.json2html)
+Use of inline functions to allow for complex logic during transformation
+Dynamic building of transform objects
+
+Please checkout the original library:
+https://github.com/moappi/jquery.json2html
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'json2html-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install json2html-rails
+
+include the following line to your javascript file:
+
+    //require json2html-rails
+
+## Usage
+
+###Example of a Transform?
+
+    var transform =
+     {tag:'li',id:'${id}',children:[
+        {tag:'span',html:'${name} ${year}'}
+      ]};
+
+      Will render into the following html:
+
+
+      <li id=1123>
+          <span>Jack and Jill (2001)</span>
+      </li>
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/json2html-rails.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json2html/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json2html-rails"
+  spec.version       = Json2html::Rails::VERSION
+  spec.authors       = ["rubyrider"]
+  spec.email         = ["irfan@e-solutionpark.com"]
+  spec.description   = %q{jquery.json2html is a jquery plug-in that implements the HTML templating engine json2html for client side browers}
+  spec.summary       = %q{json2html is a javascript HTML templating engine which converts json object to html using json transforms. Note that this jquery.json2html package includes the latest version of json2html.}
+  spec.homepage      = "https://github.com/rubyrider/json2html-rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "vendor"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/json2html/rails.rb

@@ -0,0 +1,7 @@
+require "json2html/rails/version"
+
+module Json2html
+  module Rails
+    # Your code goes here...
+  end
+end

data/lib/json2html/rails/version.rb

@@ -0,0 +1,5 @@
+module Json2html
+  module Rails
+    VERSION = "0.0.2"
+  end
+end

data/vendor/assets/javascripts/jquery.json2html.js

@@ -0,0 +1,74 @@
+//Copyright (c) 2013 Crystalline Technologies
+//
+//  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.
+
+(function($){	
+
+	//Main method
+	$.fn.json2html = function(json, transform, _options){	
+		
+		//Make sure we have the json2html base loaded
+		if(typeof json2html === 'undefined') return(undefined);
+
+		//Default Options
+		var options = {
+			'append':true,
+			'replace':false,
+			'prepend':false,
+			'eventData':{}
+		};
+
+		//Extend the options (with defaults)
+		if( _options !== undefined ) $.extend(options, _options);
+
+		//Insure that we have the events turned (Required)
+		options.events = true;
+		
+		//Make sure to take care of any chaining
+		return this.each(function(){ 
+			
+			//let json2html core do it's magic
+			var result = json2html.transform(json, transform, options);
+			
+			//Attach the html(string) result to the DOM
+			var dom = $(document.createElement('i')).html(result.html);
+
+			//Determine if we have events
+			for(var i = 0; i < result.events.length; i++) {
+				
+				var event = result.events[i];
+
+				//find the associated DOM object with this event
+				var obj = $(dom).find("[json2html-event-id-"+event.type+"='" + event.id + "']");
+
+				//Check to see if we found this element or not
+				if(obj.length === 0) throw 'jquery.json2html was unable to attach event ' + event.id + ' to DOM';
+				
+				//remove the attribute
+				$(obj).removeAttr('json2html-event-id-'+event.type);
+
+				//attach the event
+				$(obj).on(event.type,event.data,function(e){
+					//attach the jquery event
+					e.data.event = e;
+
+					//call the appropriate method
+					e.data.action.call($(this),e.data);
+				});
+			}
+
+			//Append it to the appropriate element
+			if (options.replace) $.fn.replaceWith.call($(this),$(dom).children());
+			else if (options.prepend) $.fn.prepend.call($(this),$(dom).children());
+			else $.fn.append.call($(this),$(dom).children());
+		});
+	};
+})(jQuery);

data/vendor/assets/javascripts/json2html-rails.js

@@ -0,0 +1,2 @@
+//= require json2html
+//= require jquery.json2html

data/vendor/assets/javascripts/json2html.js

@@ -0,0 +1,356 @@
+//Copyright (c) 2013 Crystalline Technologies
+//
+//  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.
+
+var json2html = {
+	
+	/* ---------------------------------------- Public Methods ------------------------------------------------ */
+	'transform': function(json,transform,_options) {
+		
+		//create the default output
+		var out = {'events':[],'html':''};
+		
+		//default options (by default we don't allow events)
+		var options = {
+			'events':false
+		};
+		
+		//extend the options
+		options = json2html._extend(options,_options);
+
+		//Make sure we have a transform & json object
+		if( transform !== undefined || json !== undefined ) {
+
+			//Normalize strings to JSON objects if necessary
+			var obj = typeof json === 'string' ? JSON.parse(json) : json;
+			
+			//Transform the object (using the options)
+			out = json2html._transform(obj, transform, options);
+		}
+		
+		//determine if we need the events
+		// otherwise return just the html string
+		if(options.events) return(out);
+			else return( out.html );
+	},
+	
+	/* ---------------------------------------- Private Methods ------------------------------------------------ */
+	
+	//Extend options
+	'_extend':function(obj1,obj2){
+		var obj3 = {};
+		for (var attrname in obj1) { obj3[attrname] = obj1[attrname]; }
+		for (var attrname in obj2) { obj3[attrname] = obj2[attrname]; }
+		return obj3;
+	},
+	
+	//Append results
+	'_append':function(obj1,obj2) {
+		var out = {'html':'','event':[]};
+		if(typeof obj1 !== 'undefined' && typeof obj2 !== 'undefined') {
+			out.html = obj1.html + obj2.html;
+
+			out.events = obj1.events.concat(obj2.events);
+		}
+
+		return(out);
+	},
+
+	//isArray (fix for IE prior to 9)
+	'_isArray':function(obj) {
+		return Object.prototype.toString.call(obj) === '[object Array]';
+	},
+	
+	//Transform object
+	'_transform':function(json, transform, options) {
+		
+		var elements = {'events':[],'html':''};
+		
+		//Determine the type of this object
+		if(json2html._isArray(json)) {
+			
+			//Itterrate through the array and add it to the elements array
+			var len=json.length;
+			for(var j=0;j<len;++j) {	
+				//Apply the transform to this object and append it to the results
+				elements = json2html._append(elements,json2html._apply(json[j], transform, j, options));
+			}
+
+		} else if(typeof json === 'object') {
+
+			//Apply the transform to this object and append it to the results
+			elements = json2html._append(elements,json2html._apply(json, transform, undefined, options));
+		}
+
+		//Return the resulting elements
+		return(elements);		
+	},
+
+	//Apply the transform at the second level
+	'_apply':function(obj, transform, index, options) {
+
+		var element = {'events':[],'html':''};
+		
+		//Itterate through the transform and create html as needed
+		if(json2html._isArray(transform)) {
+			
+			var t_len = transform.length;
+			for(var t=0; t < t_len; ++t) {
+				//transform the object and append it to the output
+				element = json2html._append(element,json2html._apply(obj, transform[t], index, options));
+			}
+
+		} else if(typeof transform === 'object') {
+
+			//Get the tag element of this transform
+			if( transform.tag !== undefined ) {
+
+				//Create a new element
+				element.html += '<' + transform.tag;
+				
+				//Create a new object for the children
+				var children = {'events':[],'html':''};
+				
+				//innerHTML
+				var html;
+
+				//Look into the properties of this transform
+				for (var key in transform) {
+
+					switch(key) {
+						case 'tag':
+							//Do nothing as we have already created the element from the tag
+						break;
+
+						case 'children':
+							//Add the children
+							if(json2html._isArray(transform.children)) {
+
+								//Apply the transform to the children
+								children = json2html._append(children,json2html._apply(obj, transform.children, index, options));
+							} else if(typeof transform.children === 'function') {
+								
+								//Get the result from the function
+								var temp = transform.children.call(obj, obj, index);
+
+								//Make sure we have an object result with the props
+								// html (string), events (array)
+								// OR a string (then just append it to the children
+								if(typeof temp === 'object') {
+									//make sure this object is a valid json2html response object
+									if(temp.html !== undefined && temp.events !== undefined) children = json2html._append(children,temp);
+								} else if(typeof temp === 'string') {
+
+									//append the result directly to the html of the children
+									children.html += temp;
+								}
+							}
+						break;
+
+						case 'html':
+							//Create the html attribute for this element
+							html = json2html._getValue(obj,transform,'html',index);
+						break;
+
+						default:
+							//Add the property as a attribute if it's not a key one
+							var isEvent = false;
+							
+							//Check if the first two characters are 'on' then this is an event
+							if( key.length > 2 )
+								if(key.substring(0,2).toLowerCase() == 'on') {
+									
+									//Determine if we should add events
+									if(options.events) {
+
+										//if so then setup the event data
+										var data = {
+											'action':transform[key],
+											'obj':obj,
+											'data':options.eventData,
+											'index':index
+										};
+										
+										//create a new id for this event
+										var id = json2html._guid();
+
+										//append the new event to this elements events
+										element.events[element.events.length] = {'id':id,'type':key.substring(2),'data':data};
+
+										//Insert temporary event property (json2html-event-id) into the element
+										element.html += " json2html-event-id-"+key.substring(2)+"='" + id + "'";
+									}
+									//this is an event
+									isEvent = true;
+								}
+
+							//If this wasn't an event AND we actually have a value then add it as a property
+							if( !isEvent){
+								//Get the value
+								var val = json2html._getValue(obj, transform, key, index);
+								
+								//Make sure we have a value
+                                if(val !== undefined) {
+                                    var out;
+                                    
+                                    //Determine the output type of this value (wrap with quotes)
+                                    if(typeof val === 'string') out = '"' + val.replace(/"/g, '&quot;') + '"';
+                                    else out = val;
+                                    
+                                    //creat the name value pair
+								    element.html += ' ' + key + '=' + out;
+                                }
+							}
+						break;
+					}
+				}
+
+				//close the opening tag
+				element.html += '>';
+				
+				//add the innerHTML (if we have any)
+				if(html) element.html += html;
+
+				//add the children (if we have any)
+				element = json2html._append(element,children);
+
+				//add the closing tag
+				element.html += '</' + transform.tag + '>';
+			}
+		}
+		
+		//Return the output object
+		return(element);
+	},
+
+	//Get a new GUID (used by events)
+	'_guid':function() {
+		var S4 = function() {
+		   return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
+		};
+		return (S4()+S4()+"-"+S4()+S4()+"-"+S4()+S4());
+	},
+
+	//Get the html value of the object
+	'_getValue':function(obj, transform, key,index) {
+		
+		var out = '';
+		
+		var val = transform[key];
+		var type = typeof val;
+		
+		if (type === 'function') {
+			return(val.call(obj,obj,index));
+		} else if (type === 'string') {
+			var _tokenizer = new json2html._tokenizer([
+				/\$\{([^\}\{]+)\}/
+			],function( src, real, re ){
+				return real ? src.replace(re,function(all,name){
+					
+					//Split the string into it's seperate components
+					var components = name.split('.');
+
+					//Set the object we use to query for this name to be the original object
+					var useObj = obj;
+
+					//Output value
+					var outVal = '';
+					
+					//Parse the object components
+					var c_len = components.length;
+					for (var i=0;i<c_len;++i) {
+
+						if( components[i].length > 0 ) {
+
+							var newObj = useObj[components[i]];
+							useObj = newObj;
+							if(useObj === null || useObj === undefined) break;
+						}
+					}
+					
+					//As long as we have an object to use then set the out
+					if(useObj !== null && useObj !== undefined) outVal = useObj;
+
+					return(outVal);
+				}) : src;
+			});
+			
+			out = _tokenizer.parse(val).join('');
+		} else {
+			out = val;
+		}
+
+		return(out);
+	},
+	
+	//Tokenizer
+	'_tokenizer':function( tokenizers, doBuild ){
+
+		if( !(this instanceof json2html._tokenizer ) )
+			return new json2html._tokenizer( tokenizers, doBuild );
+			
+		this.tokenizers = tokenizers.splice ? tokenizers : [tokenizers];
+		if( doBuild )
+			this.doBuild = doBuild;
+
+		this.parse = function( src ){
+			this.src = src;
+			this.ended = false;
+			this.tokens = [ ];
+			do {
+				this.next();
+			} while( !this.ended );
+			return this.tokens;
+		};
+		
+		this.build = function( src, real ){
+			if( src )
+				this.tokens.push(
+					!this.doBuild ? src :
+					this.doBuild(src,real,this.tkn)
+				);	
+		};
+
+		this.next = function(){
+			var self = this,
+				plain;
+				
+			self.findMin();
+			plain = self.src.slice(0, self.min);
+			
+			self.build( plain, false );
+				
+			self.src = self.src.slice(self.min).replace(self.tkn,function( all ){
+				self.build(all, true);
+				return '';
+			});
+			
+			if( !self.src )
+				self.ended = true;
+		};
+
+		this.findMin = function(){
+			var self = this, i=0, tkn, idx;
+			self.min = -1;
+			self.tkn = '';
+			
+			while(( tkn = self.tokenizers[i++]) !== undefined ){
+				idx = self.src[tkn.test?'search':'indexOf'](tkn);
+				if( idx != -1 && (self.min == -1 || idx < self.min )){
+					self.tkn = tkn;
+					self.min = idx;
+				}
+			}
+			if( self.min == -1 )
+				self.min = self.src.length;
+		};
+	}
+};

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: json2html-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- rubyrider
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: jquery.json2html is a jquery plug-in that implements the HTML templating
+  engine json2html for client side browers
+email:
+- irfan@e-solutionpark.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- json2html-rails.gemspec
+- lib/json2html/rails.rb
+- lib/json2html/rails/version.rb
+- vendor/assets/javascripts/.keep
+- vendor/assets/javascripts/jquery.json2html.js
+- vendor/assets/javascripts/json2html-rails.js
+- vendor/assets/javascripts/json2html.js
+- vendor/assets/stylesheets/.keep
+homepage: https://github.com/rubyrider/json2html-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- vendor
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: json2html is a javascript HTML templating engine which converts json object
+  to html using json transforms. Note that this jquery.json2html package includes
+  the latest version of json2html.
+test_files: []