shibori 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ca62cc5fc76a05afafe004462b6abd9a0b6135d
+  data.tar.gz: 5938d8d9776a90fe53f8948569981d4792e1c6ec
+SHA512:
+  metadata.gz: c4e3c6a0a7581b46fb5dc2010523f1a9d690ea1e507e6ff5462c83892dea0c2adbf789e07928fac366a24b356018282a5e008310701cc9adced9a96cda2ccb9b
+  data.tar.gz: 42606bb007ce66b3145135e136b646e9ca1f05194f7568278b1007e8771f483618980baf9f42b4f8ecf95e4c6ff08c2ddcfaf9226f0690b6e14f9cc7b08e299a

data/.gitignore

@@ -0,0 +1,20 @@
+node_modules/
+.DS_Store
+public/index.html
+public/styleguide.html
+public/styleguide/html/styleguide.html
+public/css/*
+public/fonts/*
+public/js/*
+public/images/*
+public/patterns/*
+config.ini
+latest-change.txt
+patternlab.json
+.sass-cache/*
+/sass-cache
+source/images/Thumbs.db
+public/styleguide/css/static.css.map
+public/styleguide/css/styleguide-specific.css.map
+public/styleguide/css/styleguide.css.map
+source/css/shibori.css.map

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    shibori (1.0.0.beta1)
+      bourbon (>= 3.1.8, < 5.0.0)
+      neat (~> 1.7, >= 1.7.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bourbon (4.2.7)
+      sass (~> 3.4)
+      thor (~> 0.19)
+    neat (1.8.0)
+      sass (>= 3.3)
+      thor (~> 0.19)
+    sass (3.4.22)
+    thor (0.19.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  shibori!
+
+BUNDLED WITH
+   1.12.5

data/Procfile

@@ -0,0 +1 @@
+web: node index.js

data/README.md

@@ -0,0 +1,24 @@
+# Shibori
+#### She • bore • ee
+Patterns for use on Heroku web properties. See the library at [shibori.herokuapp.com](http://shibori.herokuapp.com)
+
+![Shibori](shibori.jpg)
+
+> [Shibori](https://en.wikipedia.org/wiki/Shibori) is a Japanese tie-dying technique, using a variety of techniques in different shapes to make different patterns.
+
+## Local setup
+Run:
+```
+script/bootstrap
+```
+
+To watch for files:
+```
+gulp serve
+```
+
+## Development alongside Rails
+In the rails app, set up bundler to use the local copy of shibori you have: `bundle config local.shibori path/to/your/local/shibori`.
+
+## Pattern lab docs
+Shibori uses the [node version](https://github.com/pattern-lab/patternlab-node) of [Pattern Lab](http://patternlab.io/). You can find documentation in this repo's [`docs`](/docs) directory.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+require 'rubygems'

data/app.json

@@ -0,0 +1,11 @@
+{
+  "name": "www-patterns",
+  "scripts": {},
+  "env": {},
+  "addons": [],
+  "buildpacks": [
+    {
+      "url": "urn:buildpack:heroku/nodejs"
+    }
+  ]
+}

data/builder/lineage_hunter.js

@@ -0,0 +1,80 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+	"use strict";
+
+	var lineage_hunter = function(){
+
+		function findlineage(pattern, patternlab){
+
+			var pa = require('./pattern_assembler');
+			var pattern_assembler = new pa();
+
+			//find the {{> template-name }} within patterns
+			var matches = pattern_assembler.find_pattern_partials(pattern);
+			if(matches !== null){
+				matches.forEach(function(match, index, matches){
+					//strip out the template cruft
+					var foundPattern = match.replace("{{> ", "").replace(" }}", "").replace("{{>", "").replace("}}", "");
+
+					// remove any potential pattern parameters. this and the above are rather brutish but I didn't want to do a regex at the time
+					if(foundPattern.indexOf('(') > 0){
+						foundPattern = foundPattern.substring(0, foundPattern.indexOf('('));
+					}
+
+					//add if it doesnt exist
+					if (pattern.lineageIndex.indexOf(foundPattern) === -1){
+
+						pattern.lineageIndex.push(foundPattern);
+
+						patternlab.patterns.forEach(function(ancestorPattern, index, patterns){
+
+							//find the pattern in question
+							var searchPattern = ancestorPattern.patternGroup + "-" + ancestorPattern.patternName;
+
+							if(searchPattern === foundPattern){
+								//create the more complex patternLineage object too
+								var l = {
+									"lineagePattern": foundPattern,
+									"lineagePath": "../../patterns/" + ancestorPattern.patternLink
+								};
+								pattern.lineage.push(JSON.stringify(l));
+
+								//also, add the lineageR entry if it doesn't exist
+								var patternLabel = pattern.patternGroup + "-" + pattern.patternName;
+								if (ancestorPattern.lineageRIndex.indexOf(patternLabel) === -1){
+									ancestorPattern.lineageRIndex.push(patternLabel);
+
+									//create the more complex patternLineage object in reverse
+									var lr = {
+										"lineagePattern": patternLabel,
+										"lineagePath": "../../patterns/" + pattern.patternLink
+									};
+									ancestorPattern.lineageR.push(JSON.stringify(lr));
+								}
+							}
+
+						});
+
+					}
+				});
+			}
+		}
+
+		return {
+			find_lineage: function(pattern, patternlab){
+				findlineage(pattern, patternlab);
+			}
+		};
+
+	};
+
+	module.exports = lineage_hunter;
+
+}());

data/builder/list_item_hunter.js

@@ -0,0 +1,106 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+	"use strict";
+
+	var list_item_hunter = function(){
+
+		var extend = require('util')._extend,
+		pa = require('./pattern_assembler'),
+		mustache = require('mustache'),
+		pattern_assembler = new pa(),
+    items = [ 'zero','one','two','three','four','five','six','seven','eight','nine','ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen','twenty'];
+
+		function processListItemPartials(pattern, patternlab){
+      //find any listitem blocks
+      var matches = pattern_assembler.find_list_items(pattern, patternlab);
+			if(matches !== null){
+				matches.forEach(function(liMatch, index, matches){
+
+          if(patternlab.config.debug){
+            console.log('found listItem of size ' + liMatch + ' inside ' + pattern.key);
+          }
+
+          //find the boundaries of the block
+          var loopNumberString = liMatch.split('.')[1].split('}')[0].trim();
+          var end = liMatch.replace('#', '/');
+          var patternBlock = pattern.template.substring(pattern.template.indexOf(liMatch) + liMatch.length, pattern.template.indexOf(end)).trim();
+
+          //build arrays that repeat the block, however large we need to
+          var repeatedBlockTemplate = [];
+          var repeatedBlockHtml = '';
+          for(var i = 0; i < items.indexOf(loopNumberString); i++){
+            repeatedBlockTemplate.push(patternBlock);
+          }
+
+          //check for a local listitems.json file
+          var listData = JSON.parse(JSON.stringify(patternlab.listitems));
+          listData = pattern_assembler.merge_data(listData, pattern.patternSpecificListJson);
+
+          //iterate over each copied block, rendering its contents along with pattenlab.listitems[i]
+          for(var i = 0; i < repeatedBlockTemplate.length; i++){
+
+            var thisBlockTemplate = repeatedBlockTemplate[i];
+            var thisBlockHTML = "";
+
+            //combine listItem data with pattern data with global data
+            var itemData = listData['' + items.indexOf(loopNumberString)]; //this is a property like "2"
+            var globalData = JSON.parse(JSON.stringify(patternlab.data));
+            var localData = JSON.parse(JSON.stringify(pattern.jsonFileData));
+
+            var allData = pattern_assembler.merge_data(globalData, localData);
+            allData = pattern_assembler.merge_data(allData, itemData[i]);
+            allData.link = extend({}, patternlab.data.link);
+
+            //check for partials within the repeated block
+            var foundPartials = pattern_assembler.find_pattern_partials({ 'template' : thisBlockTemplate });
+
+            if(foundPartials && foundPartials.length > 0){
+
+              for(var j = 0; j < foundPartials.length; j++){
+
+                //get the partial
+                var partialName = foundPartials[j].match(/([a-z-]+)/ig)[0];
+                var partialPattern = pattern_assembler.get_pattern_by_key(partialName, patternlab);
+
+                //replace its reference within the block with the extended template
+                thisBlockTemplate = thisBlockTemplate.replace(foundPartials[j], partialPattern.extendedTemplate);
+              }
+
+              //render with data
+              thisBlockHTML = pattern_assembler.renderPattern(thisBlockTemplate, allData, patternlab.partials);
+
+            } else{
+              //just render with mergedData
+              thisBlockHTML = pattern_assembler.renderPattern(thisBlockTemplate, allData, patternlab.partials);
+            }
+
+            //add the rendered HTML to our string
+            repeatedBlockHtml = repeatedBlockHtml + thisBlockHTML;
+          }
+
+          //replace the block with our generated HTML 
+          var repeatingBlock = pattern.extendedTemplate.substring(pattern.extendedTemplate.indexOf(liMatch), pattern.extendedTemplate.indexOf(end) + end.length);
+          pattern.extendedTemplate = pattern.extendedTemplate.replace(repeatingBlock, repeatedBlockHtml);
+
+				});
+			}
+		}
+
+		return {
+			process_list_item_partials: function(pattern, patternlab){
+				processListItemPartials(pattern, patternlab);
+			}
+		};
+
+	};
+
+	module.exports = list_item_hunter;
+
+}());

data/builder/media_hunter.js

@@ -0,0 +1,51 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+	"use strict";
+
+	var diveSync = require('diveSync'),
+	path = require('path'),
+	fs = require('fs-extra');
+
+	var media_hunter = function(){
+
+		function findMediaQueries(dir, patternlab){
+			patternlab.mediaQueries = [];
+
+			diveSync(dir, function(err, file){
+				if(path.extname(file) === '.css'){
+					var contents = fs.readFileSync(file, 'utf8');
+					var safeContents = contents.replace("\r", " ").replace("\n", " ");
+					var matches = safeContents.match(/\((min|max)-width:([ ]+)?(([0-9]{1,5})(\.[0-9]{1,20}|)(px|em))/g);
+					for(var i = 0; i < matches.length; i++){
+						var breakpoint = matches[i].substring(matches[i].indexOf(':') + 1).trimLeft();
+						if(patternlab.mediaQueries.indexOf(breakpoint) === -1){
+							patternlab.mediaQueries.push(breakpoint);
+						}
+					}
+				}
+			});
+			patternlab.mediaQueries.sort(function(a,b){
+				var integerPartA = a.match(/(?:\d*\.)?\d+/g);
+				var integerPartB = b.match(/(?:\d*\.)?\d+/g);
+				return parseInt(a,10) > parseInt(b,10);
+			});
+		}
+
+		return {
+			find_media_queries: function(dir, patternlab){
+				findMediaQueries(dir, patternlab);
+			}
+		};
+
+	};
+
+	module.exports = media_hunter;
+
+}());

data/builder/object_factory.js

@@ -0,0 +1,60 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+  "use strict";
+
+  var oPattern = function(subdir, filename, data){
+    this.fileName = filename.substring(0, filename.indexOf('.'));
+    this.subdir = subdir;
+    this.name = subdir.replace(/[\/\\]/g, '-') + '-' + this.fileName; //this is the unique name with the subDir
+    this.jsonFileData = data || {};
+    this.patternName = this.fileName.substring(this.fileName.indexOf('-') + 1); //this is the display name for the ui
+    this.patternLink = this.name + '/' + this.name + '.html';
+    this.patternGroup = this.name.substring(this.name.indexOf('-') + 1, this.name.indexOf('-', 4) + 1 - this.name.indexOf('-') + 1);
+    this.patternSubGroup = subdir.substring(subdir.indexOf('/') + 4);
+    this.flatPatternPath = subdir.replace(/[\/\\]/g, '-');
+    this.key = this.patternGroup + '-' + this.patternName;
+    this.template = '';
+    this.patternPartial = '';
+    this.lineage = [];
+    this.lineageIndex = [];
+    this.lineageR = [];
+    this.lineageRIndex = [];
+  };
+
+  var oBucket = function(name){
+    this.bucketNameLC = name;
+    this.bucketNameUC = name.charAt(0).toUpperCase() + name.slice(1);
+    this.navItems = [];
+    this.navItemsIndex = [];
+    this.patternItems = [];
+    this.patternItemsIndex = [];
+  };
+
+  var oNavItem = function(name){
+    this.sectionNameLC = name;
+    this.sectionNameUC = name.charAt(0).toUpperCase() + name.slice(1);
+    this.navSubItems = [];
+    this.navSubItemsIndex = [];
+  };
+
+  var oNavSubItem = function(name){
+    this.patternPath = '';
+    this.patternPartial = '';
+    this.patternName = name.charAt(0).toUpperCase() + name.slice(1);
+  };
+
+  module.exports = {
+    oPattern: oPattern,
+    oBucket: oBucket,
+    oNavItem: oNavItem,
+    oNavSubItem: oNavSubItem
+  };
+
+}());

data/builder/parameter_hunter.js

@@ -0,0 +1,69 @@
+/** 
+ * Heroku-Patterns - v0.2.0 - 2016
+ * 
+ * , and the web community.
+ * Licensed under the  license.
+ * 
+ * Many thanks to Brad Frost and Dave Olsen for inspiration, encouragement, and advice.
+ * 
+ **/(function () {
+	"use strict";
+
+	var parameter_hunter = function(){
+
+		var extend = require('util')._extend,
+		pa = require('./pattern_assembler'),
+		mustache = require('mustache'),
+		pattern_assembler = new pa();
+
+		function findparameters(pattern, patternlab){
+
+			//find the {{> template-name(*) }} within patterns
+			var matches = pattern.template.match(/{{>([ ]+)?([\w\-\.\/~]+)(\()(.+)(\))([ ]+)?}}/g);
+			if(matches !== null){
+				//compile this partial immeadiately, essentially consuming it.
+				matches.forEach(function(pMatch, index, matches){
+					//find the partial's name
+					var partialName = pMatch.match(/([\w\-\.\/~]+)/g)[0];
+
+					if(patternlab.config.debug){
+						console.log('found patternParameters for ' + partialName);
+					}
+
+					//strip out the additional data and eval
+					var leftParen = pMatch.indexOf('(');
+					var rightParen = pMatch.indexOf(')');
+					var paramString =  '({' + pMatch.substring(leftParen + 1, rightParen) + '})';
+
+					//do no evil. there is no good way to do this that I can think of without using a split, which then makes commas and colons special characters and unusable within the pattern params
+					var paramData = eval(paramString);
+
+					var partialPattern = pattern_assembler.get_pattern_by_key(partialName, patternlab);
+					var globalData = JSON.parse(JSON.stringify(patternlab.data));
+					var localData = JSON.parse(JSON.stringify(pattern.jsonFileData));
+
+					var allData = pattern_assembler.merge_data(globalData, localData);
+					allData = pattern_assembler.merge_data(allData, paramData);
+
+					//extend pattern data links into link for pattern link shortcuts to work. we do this locally and globally
+					allData.link = extend({}, patternlab.data.link);
+
+					var renderedPartial = pattern_assembler.renderPattern(partialPattern.extendedTemplate, allData, patternlab.partials);
+
+					//remove the parameter from the partial and replace it with the rendered partial + paramData
+					pattern.extendedTemplate = pattern.extendedTemplate.replace(pMatch, renderedPartial);
+				});
+			}
+		}
+
+		return {
+			find_parameters: function(pattern, patternlab){
+				findparameters(pattern, patternlab);
+			}
+		};
+
+	};
+
+	module.exports = parameter_hunter;
+
+}());