widget_builder 0.1.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90f4cc2d815c5777c210e44d1ba56ada0aaa31d6
+  data.tar.gz: b02ca2bee98891fcfd4ad0c67e6f5e777fe97ee1
+SHA512:
+  metadata.gz: d1d859a96e2c5304e143996285bfba1f281d2621edc076734dda1a91ffce298ece03e52d5c6c024892fa62b40698e3067a92609ae8be7192f03c50e4058a9b7a
+  data.tar.gz: 6a3da34735f718f98adaf536434dc9f06b8a146499581e09124e15a3ba070490128e0c5abb0ffe8f3ccd5b93189c7322e31374fb0f6704338eb4db072fe6a761

data/.gitignore

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

data/.rspec

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

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+* Initial release

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Endri Gjiri
+
+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,141 @@
+# WidgetBuilder
+
+By: Endri Gjiri *www.name-reaction.com*
+
+**WidgetBuilder** aims to be a simple way to create javascript widgets. It allows developers to work separately on the html, css, and javascript files for their widgets. WidgetBuilder combines all of these files into a single minified javascript file, ready to be loaded by the end user. WidgetBuilder also wraps everything with a javascript Widget class, namespacing everything, and allows the display of multiple widgets in the same page without conflicts.
+#### Other Features include:
+- Provides a simple and small snippet for the user on which to load the widget. It only consists of an anchor tag with a class of the specific ```widget_name``` and the script tag to load the generated widget javascript.
+- The a tag on which the widget is loaded on top of can serve as a way to pass options to the widget js through the a tag's data attributes. This data can be used to customize the widget's function or style.
+- Provides a ```validateReference``` function that checks if the developer's site is referenced properly SEO-wise and if not it destroys the widget. This function needs to be called explicitly in the developer's custom javascript.
+- Provides a ```resetCSS``` function which minimizes style conflicts with the sites that the widget ultimately ends up in.
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'widget_builder'
+```
+
+And then execute:
+```console
+$ bundle install
+```
+
+Or install it yourself as:
+```console
+$ gem install widget_builder
+```
+
+### Brief description of the Ruby classes
+
+WidgetBuilder consists of a Ruby module of the same name which contains two classes named **Widget** and **Widgets** (plural).
+
+The main class is the **Widget** class which needs 3 arguments, the html_path, css_path, and js_path respectively. It also has a forth optional argument which is an options hash. This class essentially reads all of these files, includes the css inline into the html, and then adds this combined html_and_css string into the javascript. This class also wraps the javascript with the gem's own ```widget_loader``` javascript which provides additional functionality to the widget. Instance methods include: ```save```, ```show_snippet```, ```report```, and ```compile```, among others.
+
+The **Widgets** (plural) class is designed to create multiple widgets at once, relying on naming conventions. It also accepts html_path, css_path, and js_path as arguments but in this case they do not refer to the file paths but instead to directory paths. This class will first go to the html directory and get all the file names and try to match them to css and js files of the same name in their respective folders. It will then loop through the list of html files and create an instance of the Widget class by passing in the html, css, and js file. The final result is an array of widgets (instances of Widget). The Widgets class also responds to ```save```, ```report```, and ```compile``` and loops over the array of widgets and calls the appropriate method on the widget instance.
+
+## Usage
+
+#### The simplest way to get started with this gem is the following:
+
+1. Place the html, css, and js files needed for the widget all in the same folder and navigate there in the console.
+
+2. Load irb and require widget_builder
+```console
+$ irb
+> require 'widget_builder'
+```
+
+3. Compile the widget directly through irb.
+```ruby
+WidgetBuilder::Widgets.new.compile
+```
+Note: When no paths are passed as attributes to the Widgets class, it defaults them to the current directory.
+
+This will create a new javascript file which is the new widget file, named according to the widget_name. The widget_name gets extracted by the class of the first div in the html or it can be passed in through the options hash.
+
+This command will also generate a report in the console, also including an html snippet that the end user can copy and place on their pages to display the widget.
+
+A sample snippet is shown below:
+```html
+<a class="chemiphi_MMC" href="http://www.name-reaction.com"></a>
+<script type="text/javascript">
+   var element = document.createElement('script');
+   element.type = 'text/javascript';
+   element.src = 'http://api.chemiphi.com/public_widgets/chemiphi_MMC.js';
+   document.getElementsByTagName('head')[0].appendChild(element);
+</script>
+```
+
+## Usage with Rails
+#### Building a widget by specifying the paths to the html, css, and js in a Rails app.
+
+A simple way to build a widget in rails is to do it by creating a custom Task.
+
+Let's create a new Ruby file "/lib/tasks/widget_compiler.rake" with the following code:
+
+```ruby
+desc "Creates a single uglified widget JavaScript file containing the custom HTML, CSS, and JS"
+task :create_widget do
+    html_path = File.join(Rails.root, 'app', 'views', 'widgets', 'my_widget.html')
+	css_path = File.join(Rails.root, 'app', 'assets', 'stylesheets', 'widgets', 'my_widget.css')
+	js_path = File.join(Rails.root, 'app', 'assets', 'javascripts', 'widgets', 'my_widget.js')
+
+	widget = WidgetBuilder::Widget.new(html_path, css_path, js_path)
+
+    export_path = File.join(Rails.root, 'public', 'widgets')
+	widget.compile(export_path)
+end
+```
+In the above code we have specified that the final widget js should be placed in a public/widgets folder so before we run this task we need to first create the widgets folder.
+
+We can then build the widget by running the following command from the console:
+```console
+$ rake create_widget
+```
+This will create the widget.js in the public/widgets folder, ready to be accessed by users and also displays in the console the HTML snippet required to display this widget.
+
+## Options
+
+#### The WidgetBuilder also accepts an options hash as a fourth argument.
+
+Available options include:
+- **compress** - *defaults to true* - specifies whether the compiled javascript file should be minified.
+- **href** - *defaults to #* - specifies the url that the snippet anchor tag should link to. This has to be passed in as an option if the *validateReference* function is called from the js file.
+- **source_path** - needed to point to the src of the compiled widget.js in the snippet. In the above example this could be *www.my_domain.com/widgets*.
+
+**Example:**
+```ruby
+options = { compress: false, href: 'www.my_domain.com', source_path: 'www.my_domain.com/widgets' }
+widget = WidgetBuilder::Widget.new(html_path, css_path, js_path, options)
+widget.compile(export_path)
+```
+
+This would create a non-minified widget javascript and final HTML snippet that looks like this:
+```html
+<a class="my_widget" href="http://www.my_domain.com"></a>
+<script type="text/javascript">
+   var element = document.createElement('script');
+   element.type = 'text/javascript';
+   element.src = 'http://www.my_domain.com/widgets/my_widget.js';
+   document.getElementsByTagName('head')[0].appendChild(element);
+</script>
+```
+## JavaScript Utilities
+#### The widget's functionality is determined in the custom javascript file that you develop.
+##### This javascript get wrapped in the gem's ```widget_loader``` js code that extends it with additional functionality.
+
+- ```var widget ``` becomes available to your custom javascript file and it stores the whole widget object. Outputting it to the console shows that it includes the widget ```id```, ```aTag```, ```dataset```, ```app```, and the ```validateRefence``` function.
+- ```var w ``` is also available to the custom javascript and it holds the whole widget as a jQuery object. This can come in handy when trying to find elements within a particular widget and can be done using ```w.find('.my_element') ``` instead of searching it on the global scope as in ```$(.my_element) ```. This can be useful when it is desirable to have multiple widgets running on the same page without conflicting with each other.
+
+## Future Work
+- As of now the only file formats that are supported are html, css, js as well as scss, and sass. In the next release I would like to extend support for haml and coffeeScript. 
+- Current integration with Rails is quite raw and does not take advantage of the capabilities of Rails. In the future I want to create another gem, likely wiget_builder-rails, that is designed specifically for working in Rails.
+
+## 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,8 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+Rake.application.options.trace = false
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/app/assets/javascripts/widget_loader.js

@@ -0,0 +1,79 @@
+// START...
+if (window.jQuery != undefined) { // If the user already has jQuery loaded on their site just start loading the widget
+	loadWidget();
+} else { // Load jQuery
+	element = document.createElement('script');
+	element.setAttribute('type', 'text/javascript');
+	element.setAttribute('src', 'https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js'); // jQuery from Google
+	document.getElementsByTagName('head')[0].appendChild(element); // add jQuery to the head
+	element.onload = loadWidget; // once jQuery has loaded, start loading the chemiphi widget
+}
+
+// Loads the widget on top of <a> tags with a class of 'widget_name'
+function loadWidget() {
+	jQuery(function($) {
+		// Note: The 'widget_name' below will be automatically replaced with the propper class from the ruby widget_builder script
+		$('a.widget_name').each(function(index, aTag) { // Creates a widget for every <a> tag with a class of widget_name 
+			new CustomWidget(aTag);
+		});
+	});
+}
+
+// Custom Widget class that include the js code from the included js_path
+function CustomWidget(aTag) {
+	var widget = new Widget(aTag); // Create an instance of the widget object
+	var w = widget.app; // 'w' is just a shortcut for the whole widget.app jQuery object
+	JAVASCRIPT_PLACEHOLDER // The rest of the javascript is then included
+}
+
+// The main Widget class.
+function Widget(aTag) {
+	this.id = aTag.className + '_' + Math.round(Math.random()*10000); // generate a random number as the id of the widget
+	this.aTag = aTag;
+	this.dataset = $(aTag).data();
+	this.app = $('<div>HTML&CSS_PLACEHOLDER</div>').attr('id', this.id);
+	$(aTag).replaceWith(this.app); // Replace the <a> tag placeholder with the widget HTML
+
+	// Destroys the widget if the referring link has been altered. This functions needs to be called to take effect
+	this.validateReference = function validateReference() {
+		var a = $(aTag);
+		if (a.attr('href') != 'HREF_PLACEHOLDER' || a.attr('rel')  == 'nofollow') {
+			this.app.remove();
+			delete this;
+			// Displays a console error alerting of the situation
+			console.error('The Widget widget_name was not loaded due to an invalid <a> tag reference.\nA valid tag would be: VALID_ATAG_PLACEHOLDER')
+		}
+	}
+}
+
+// Utility function that sets the CSS of elements to defaults if they are not already set
+function resetCSS(element, andChildren) {
+	// if andChildren is true, reset the styles of the specified jQuery object and all its children
+	var elements = andChildren ? element.find('*').andSelf() : element;
+	elements.each( function() {
+		var defaultStyles = {
+			'margin-top':       '0px',
+			'margin-bottom':    '0px',
+			'margin-left':      '0px',
+			'margin-right':     '0px',
+			'padding-top':      '0px',
+			'padding-bottom':   '0px',
+			'padding-left':     '0px',
+			'padding-right':    '0px',
+			'font-size':        'normal',
+			'font-style':       'normal',
+			'font-variant':     'normal',
+			'font-weight':      'normal',
+			'line-height':      'normal',
+			'vertical-align':   'baseline',
+			'color':            'black',
+			'background-color': 'transparent'
+		}; // Need to reset borders, fonts etc.
+		for (var key in defaultStyles) {
+			if (!this.style[key])
+				this.style[key] = defaultStyles[key];
+		}
+	});
+	return element // return the jQuery object back for possible chaining
+}
+

data/lib/widget_builder/constants.rb

@@ -0,0 +1,4 @@
+module WidgetBuilder
+	ROOT_PATH = File.join(File.absolute_path(File.dirname __FILE__), '..', '..')
+	WIDGET_LOADER_PATH = File.join(ROOT_PATH, 'app', 'assets', 'javascripts', 'widget_loader.js')
+end

data/lib/widget_builder/version.rb

@@ -0,0 +1,3 @@
+module WidgetBuilder
+  VERSION = "0.1.0.alpha"
+end

data/lib/widget_builder.rb

@@ -0,0 +1,212 @@
+require 'widget_builder/constants'
+require 'awesome_print'
+require 'yui/compressor'
+require 'premailer'
+require 'sass'
+require 'find'
+
+module WidgetBuilder
+
+	# Creates a single Widget by passing in the path to the html, css, and js files.
+	class Widget
+		def initialize(html_path, css_path, js_path, options = {})
+			@html_path, @css_path, @js_path = html_path, css_path, js_path
+
+			defaults = { compress: true }
+			defaults.merge(options).each do |k, v|
+				instance_variable_set("@#{k}",v)
+			end
+
+			@html = html
+			@widget_name ||= widget_name # the widget name is either passed in as an option or extrapolated from the html
+			@href = href
+
+			@css = css
+			@js = js
+		end
+
+		def html
+			File.read @html_path
+		end
+
+		# Get the widget name from the class of the first div tag in the html
+		def widget_name
+			@html.match(/<div\s+?class=(['"])(\w+)(?:\s+\w*)*\1/i)[2]
+		end
+
+		def css
+			css = File.read @css_path # Reads the css or scss file
+			css_folder = File.dirname @css_path # Infers the css foler
+
+			# Scans the file for any @import rules and includes their content
+			css.scan(/(^\s*@import\s+(?:url[\( ])?(['"])([\w\.]+)\2.*;)/).each do |m|
+				Find.find(css_folder) do |path|
+					css.gsub!(m[0], File.read(path)) if path.match(m[2])
+				end
+			end
+
+			# Determines the suffics of the file
+			suffix = @css_path.split('.').last
+			if suffix == 'css' # Just return the css if it is a plain css file
+				css
+			elsif suffix =~ /^scss|sass$/ # handle Sass files with the Sass Engine
+				engine = Sass::Engine.new(css, syntax: suffix.to_sym)
+				engine.render # converts scss or sass to plain css
+			else
+				raise 'Invalid css format'
+			end
+		end
+
+		def html_with_css
+			premailer = Premailer.new(@html, { with_html_string: true, remove_comments: true, css_string: @css })
+			html_with_css = premailer.to_inline_css # places all the css inline with the html code
+			html_with_css = WidgetBuilder.remove_excess_premailer_content(html_with_css) # cleans up excess styles
+			if @compress == true
+				WidgetBuilder.html_uglifier(html_with_css) # removes html comments and unnecessary spaces
+			else
+				html_with_css.gsub("\n", " \\\n") # returns the html as is but adds trailing backslashes after each line to allow the multiline string in JavaScript
+			end
+		end
+
+		# Properly formats the href for the widget a tag or returns '#' if not provided
+		def href
+			if href = @href
+				href.gsub!(/^http:\/\//, '') # removes leading http:// if present since it gets added in the next step
+				"http://#{href}"
+			else
+				'#'
+			end
+		end
+
+		# Generates the final js file with all included html & css
+		def js
+			js = File.read WidgetBuilder::WIDGET_LOADER_PATH # reads the widget_loader js
+			js.gsub!(/widget_name/, @widget_name) # adds the widget name to the js file
+			js.gsub!(/JAVASCRIPT_PLACEHOLDER/, File.read(@js_path)) # adds the custom js to the widget_loader js
+			js.gsub!(/HTML&CSS_PLACEHOLDER/, html_with_css) # includes the html & css
+			js.gsub!(/HREF_PLACEHOLDER/, @href) # adds the href to the js validateReference function
+			js.gsub!(/VALID_ATAG_PLACEHOLDER/, %Q{<a class="#{@widget_name}" href="#{@href}"></a>})
+			if @compress == true 
+				YUI::JavaScriptCompressor.new(munge: true).compress(js) # uglifies the combined javascript
+			else
+				js # Otherwise returns the raw non-minified javascript
+			end
+		end
+
+		# Saves the final js file to the specified path
+		def save(path = File.dirname(@js_path))
+			new_js_path = File.join(path, @widget_name + '.js')
+			File.open(new_js_path, 'w') do |f|
+				f.write @js
+			end
+		end
+
+		def show_snippet
+			# Properly format or generate the javascript widget src path
+			if source_path = @source_path
+				source_path.gsub!(/^http:\/\//, '') # removes leading http:// if present since it gets added later
+				source_path.gsub!(/\/$/, '') # removes trailing slash if present since it gets added later
+			else
+				source_path = 'SOURCE_PATH_PLACEHOLDER'
+				ap "NOTE: Make sure to replace the #{source_path} in the code snippet below.", color: {string: :redish}	
+			end
+
+			ap "------------ Copy the following HTML snippet to display the widget. -------------", color: {string: :cyanish}
+puts %Q{<a class="#{@widget_name}" href="#{@href}"></a>
+<script type="text/javascript">
+   var element = document.createElement('script');
+   element.type = 'text/javascript';
+   element.src = 'http://#{source_path}/#{@widget_name}.js';
+   document.getElementsByTagName('head')[0].appendChild(element);
+</script>}
+			ap "---------------------------------------------------------------------------------", color: {string: :cyanish}
+		end
+
+		# Outputs a nice report on the console
+		def report
+			puts 
+			ap "Widget name: #{@widget_name}",								color: {string: :redish}
+			ap "HTML Template: #{@html_path.split('/').last}",			color: {string: :greenish}
+			ap "Javascript reference: #{@js_path.split('/').last}",	color: {string: :greenish}
+			ap "Stylesheet reference: #{@css_path.split('/').last}", color: {string: :greenish}
+			ap "HTML with CSS:"
+			puts html_with_css
+			ap "Final Compilation of the JS File (includes html, css, and js):", color: {string: :greenish}
+			puts @js
+			show_snippet
+		end
+
+		def compile(path = File.dirname(@js_path))
+			save(path)
+			report
+		end
+	end
+
+	# Crates an array of Widgets by passing in the paths to the html, css, and js directories
+	class Widgets
+		def initialize(html_path = '.', css_path = '.', js_path = '.', options = {})
+			@html_path, @css_path, @js_path, @options = html_path, css_path, js_path, options
+			@widgets = widgets
+		end
+
+		def widgets
+			widgets = []
+			Dir.foreach(@html_path) do |file| # read all the files in the 'Widget html' directory
+				if (file.match(/\.html$/)) # only consider html files for now
+					html_path = File.join(@html_path, file)
+
+					# HTML, CSS, and JS files should have the same name but different extensions
+					filename = file.gsub('.html', '')
+
+					css_path = ''
+					Find.find(@css_path) do |path|
+						css_path = path if path.split('/').last.match(/^#{filename}.*?\.(?:css|scss|sass)$/)
+					end
+
+					js_path = ''
+					Find.find(@js_path) do |path|
+						js_path = path if path.split('/').last.match(/^#{filename}\.js$/) # NOTE: Needs to add CoffeeScript support
+					end
+					widgets << WidgetBuilder::Widget.new(html_path, css_path, js_path, @options)
+				end
+			end
+			widgets
+		end
+
+		def save(path = @js_path)
+			widgets.each { |widget| widget.save(path) }
+		end
+
+		def report
+			widgets.each { |widget| widget.report }
+		end
+
+		def compile(path = File.dirname(@js_path))
+			widgets.each { |widget| widget.compile(path) }
+		end
+	end
+
+	# Utility methods
+	private
+
+	# removes styles that were added by default with the pre-mailer gem
+	def self.remove_excess_premailer_content(html)
+		html = html.gsub(/^.*?<body.*?>(.*?)<\/body>.*$/m,'\1') # removes created html and body tags
+		html = html.gsub(/\s*font-size:\s*normal\s*;\s*/, '')
+		html = html.gsub(/\s*font-style:\s*normal\s*;\s*/, '')
+		html = html.gsub(/\s*font-variant:\s*normal\s*;\s*/, '')
+		html = html.gsub(/\s*line-height:\s*normal\s*;\s*/, '')
+		html = html.gsub(/\s*font-weight:\s*normal\s*;\s*/, '')
+	end
+
+	# removes html comments and unnecessary spaces
+	def self.html_uglifier(html)
+		html = html.gsub(/<!--.*?-->/m, '') # remove html comments
+		html = html.gsub(/[\n\r\t]/m, '') # remove new lines, line returns, and tabs
+		html = html.gsub(/>\s+?</m, '><') # remove excess whitespace between tags
+		html = html.gsub(/\s+?/m, ' ') # remove excess whitespace between elements
+		html = html.gsub(/<\s+?/m, '<') # remove excess whitespace after <
+		html = html.gsub(/\s+?>/m, '>') # remove excess whitespace before >
+	end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'widget_builder'

data/spec/widget_builder_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe WidgetBuilder do
+end

data/widget_builder.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'widget_builder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "widget_builder"
+  spec.version       = WidgetBuilder::VERSION
+  spec.authors       = ["Endri Gjiri"]
+  spec.email         = ["egjiri@gmail.com"]
+  spec.description   = %q{A widget builder tool}
+  spec.summary       = %q{WidgetBuilder}
+  spec.homepage      = ""
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_dependency "awesome_print"
+  spec.add_dependency "sass"
+  spec.add_dependency "yui-compressor"
+  spec.add_dependency "premailer"
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: widget_builder
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha
+platform: ruby
+authors:
+- Endri Gjiri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-24 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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sass
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yui-compressor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: premailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A widget builder tool
+email:
+- egjiri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/widget_loader.js
+- lib/widget_builder.rb
+- lib/widget_builder/constants.rb
+- lib/widget_builder/version.rb
+- spec/spec_helper.rb
+- spec/widget_builder_spec.rb
+- widget_builder.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: WidgetBuilder
+test_files:
+- spec/spec_helper.rb
+- spec/widget_builder_spec.rb