bigtextjs_rails 0.1.4

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Guy Israeli
+
+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,42 @@
+# BigtextjsRails
+
+BigText Makes Text Big. This gem will help you do it the rails way.
+
+See the demo http://www.zachleat.com/bigtext/demo/
+
+and see here for docs
+https://github.com/zachleat/BigText
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bigtextjs_rails'
+
+requires jQuery
+
+and add 
+
+    //= require bigtext
+
+to application.js
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bigtextjs_rails
+
+## Usage
+
+see here for docs
+https://github.com/zachleat/BigText
+## 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/app/assets/javascripts/bigtext.js

@@ -0,0 +1,295 @@
+/*! BigText - v0.1.4 - 2013-08-24
+* https://github.com/zachleat/BigText
+* Copyright (c) 2013 @zachleat; Licensed MIT
+*/
+
+;(function(window, $) {
+  var counter = 0,
+    $headCache = $('head'),
+    oldBigText = window.BigText,
+    oldjQueryMethod = $.fn.bigtext,
+    BigText = {
+      DEBUG_MODE: false,
+      DEFAULT_MIN_FONT_SIZE_PX: null,
+      DEFAULT_MAX_FONT_SIZE_PX: 528,
+      GLOBAL_STYLE_ID: 'bigtext-style',
+      STYLE_ID: 'bigtext-id',
+      LINE_CLASS_PREFIX: 'bigtext-line',
+      EXEMPT_CLASS: 'bigtext-exempt',
+      DEFAULT_CHILD_SELECTOR: '> div',
+      childSelectors: {
+        div: '> div',
+        ol: '> li',
+        ul: '> li'
+      },
+      noConflict: function(restore)
+      {
+        if(restore) {
+          $.fn.bigtext = oldjQueryMethod;
+          window.BigText = oldBigText;
+        }
+        return BigText;
+      },
+      test: {
+        noFractionalFontSize: (function() {
+          if( !( 'getComputedStyle' in window ) || !( 'body' in document ) ) {
+            return true;
+          }
+          var test = $('<div/>').css({
+              position: 'absolute',
+              'font-size': '14.1px'
+            }).appendTo(document.body).get(0),
+            computedStyle = window.getComputedStyle( test, null );
+
+          return computedStyle ? computedStyle.getPropertyValue( 'font-size' ) === '14px' : true;
+        })()
+      },
+      init: function() {
+        if(!$('#'+BigText.GLOBAL_STYLE_ID).length) {
+          $headCache.append(BigText.generateStyleTag(BigText.GLOBAL_STYLE_ID, ['.bigtext * { white-space: nowrap; } .bigtext > * { display: block; }',
+                                          '.bigtext .' + BigText.EXEMPT_CLASS + ', .bigtext .' + BigText.EXEMPT_CLASS + ' * { white-space: normal; }']));
+        }
+      },
+      bindResize: function(eventName, resizeFunction) {
+        if($.throttle) {
+          // https://github.com/cowboy/jquery-throttle-debounce
+          $(window).unbind(eventName).bind(eventName, $.throttle(100, resizeFunction));
+        } else {
+          if($.fn.smartresize) {
+            // https://github.com/lrbabe/jquery-smartresize/
+            eventName = 'smartresize.' + eventName;
+          }
+          $(window).unbind(eventName).bind(eventName, resizeFunction);
+        }
+      },
+      getStyleId: function(id)
+      {
+        return BigText.STYLE_ID + '-' + id;
+      },
+      generateStyleTag: function(id, css)
+      {
+        return $('<style>' + css.join('\n') + '</style>').attr('id', id);
+      },
+      clearCss: function(id)
+      {
+        var styleId = BigText.getStyleId(id);
+        $('#' + styleId).remove();
+      },
+      generateCss: function(id, linesFontSizes, lineWordSpacings, minFontSizes)
+      {
+        var css = [];
+
+        BigText.clearCss(id);
+
+        for(var j=0, k=linesFontSizes.length; j<k; j++) {
+          css.push('#' + id + ' .' + BigText.LINE_CLASS_PREFIX + j + ' {' +
+            (minFontSizes[j] ? ' white-space: normal;' : '') +
+            (linesFontSizes[j] ? ' font-size: ' + linesFontSizes[j] + 'px;' : '') +
+            (lineWordSpacings[j] ? ' word-spacing: ' + lineWordSpacings[j] + 'px;' : '') +
+            '}');
+        }
+
+        return BigText.generateStyleTag(BigText.getStyleId(id), css);
+      },
+      jQueryMethod: function(options)
+      {
+        BigText.init();
+    
+        options = $.extend({
+              minfontsize: BigText.DEFAULT_MIN_FONT_SIZE_PX,
+              maxfontsize: BigText.DEFAULT_MAX_FONT_SIZE_PX,
+              childSelector: '',
+              resize: true
+            }, options || {});
+      
+        return this.each(function()
+        {
+          var $t = $(this).addClass('bigtext'),
+            childSelector = options.childSelector ||
+                  BigText.childSelectors[this.tagName.toLowerCase()] ||
+                  BigText.DEFAULT_CHILD_SELECTOR,
+            maxWidth = $t.width(),
+            id = $t.attr('id');
+
+          if(!id) {
+            id = 'bigtext-id' + (counter++);
+            $t.attr('id', id);
+          }
+    
+          if(options.resize) {
+            BigText.bindResize('resize.bigtext-event-' + id, function()
+            {
+              // TODO only call this if the width has changed.
+              BigText.jQueryMethod.call($('#' + id), options);
+            });
+          }
+    
+          BigText.clearCss(id);
+    
+          $t.find(childSelector).addClass(function(lineNumber, className)
+          {
+            // remove existing line classes.
+            return [className.replace(new RegExp('\\b' + BigText.LINE_CLASS_PREFIX + '\\d+\\b'), ''),
+                BigText.LINE_CLASS_PREFIX + lineNumber].join(' ');
+          });
+    
+          var sizes = calculateSizes($t, childSelector, maxWidth, options.maxfontsize, options.minfontsize);
+          $headCache.append(BigText.generateCss(id, sizes.fontSizes, sizes.wordSpacings, sizes.minFontSizes));
+        });
+      }
+    };
+
+  function testLineDimensions($line, maxWidth, property, size, interval, units, previousWidth)
+  {
+    var width,
+      previousWidth = typeof previousWidth == 'number' ? previousWidth : 0;
+    $line.css(property, size + units);
+
+    width = $line.width();
+
+    if(width >= maxWidth) {
+// console.log(width, ' previous: ' + previousWidth, property + ' at ' + interval, 'prior: ' + (parseFloat(size) - interval), 'new:' + parseFloat(size));
+      $line.css(property, '');
+
+      if(width == maxWidth) {
+        return {
+          match: 'exact',
+          size: parseFloat((parseFloat(size) - 0.1).toFixed(3))
+        };
+      }
+
+      // Since this is an estimate, we calculate how far over the width we went with the new value.
+      // If this is word-spacing (our last resort guess) and the over is less than the under, we keep the higher value.
+      // Otherwise, we revert to the underestimate.
+      var under = maxWidth - previousWidth,
+        over = width - maxWidth;
+
+      return {
+        match: 'estimate',
+        size: parseFloat((parseFloat(size) - (property === 'word-spacing' && previousWidth && ( over < under ) ? 0 : interval)).toFixed(3))
+      };
+    }
+
+    return width;
+  }
+
+  function calculateSizes($t, childSelector, maxWidth, maxFontSize, minFontSize)
+  {
+    var $c = $t.clone(true)
+          .addClass('bigtext-cloned')
+          .css({
+            fontFamily: $t.css('font-family'),
+            textTransform: $t.css('text-transform'),
+            wordSpacing: $t.css('word-spacing'),
+            letterSpacing: $t.css('letter-spacing'),
+            position: 'absolute',
+            left: BigText.DEBUG_MODE ? 0 : -9999,
+            top: BigText.DEBUG_MODE ? 0 : -9999
+          }).appendTo(document.body);
+
+    // font-size isn't the only thing we can modify, we can also mess with:
+    // word-spacing and letter-spacing. WebKit does not respect subpixel
+    // letter-spacing, word-spacing, or font-size.
+    // TODO try -webkit-transform: scale() as a workaround.
+    var fontSizes = [],
+      wordSpacings = [],
+      minFontSizes = [],
+      ratios = [];
+
+    $c.find(childSelector).css('float', 'left').each(function(lineNumber) {
+      var $line = $(this),
+        // TODO replace 8, 4 with a proportional size to the calculated font-size.
+        intervals = BigText.test.noFractionalFontSize ? [8, 4, 1] : [8, 4, 1, 0.1],
+        lineMax;
+
+      if($line.hasClass(BigText.EXEMPT_CLASS)) {
+        fontSizes.push(null);
+        ratios.push(null);
+        minFontSizes.push(false);
+        return;
+      }
+
+      // TODO we can cache this ratio?
+      var autoGuessSubtraction = 32, // font size in px
+        currentFontSize = parseFloat($line.css('font-size')),
+        ratio = ( $line.width() / currentFontSize ).toFixed(6);
+
+      newFontSize = parseInt( maxWidth / ratio, 10 ) - autoGuessSubtraction;
+
+      outer: for(var m=0, n=intervals.length; m<n; m++) {
+        inner: for(var j=1, k=10; j<=k; j++) {
+          if(newFontSize + j*intervals[m] > maxFontSize) {
+            newFontSize = maxFontSize;
+            break outer;
+          }
+
+          lineMax = testLineDimensions($line, maxWidth, 'font-size', newFontSize + j*intervals[m], intervals[m], 'px', lineMax);
+          if(typeof lineMax !== 'number') {
+            newFontSize = lineMax.size;
+
+            if(lineMax.match == 'exact') {
+              break outer;
+            }
+            break inner;
+          }
+        }
+      }
+
+      ratios.push(maxWidth / newFontSize);
+
+      if(newFontSize > maxFontSize) {
+        fontSizes.push(maxFontSize);
+        minFontSizes.push(false);
+      } else if(!!minFontSize && newFontSize < minFontSize) {
+        fontSizes.push(minFontSize);
+        minFontSizes.push(true);
+      } else {
+        fontSizes.push(newFontSize);
+        minFontSizes.push(false);
+      }
+    }).each(function(lineNumber) {
+      var $line = $(this),
+        wordSpacing = 0,
+        interval = 1,
+        maxWordSpacing;
+
+      if($line.hasClass(BigText.EXEMPT_CLASS)) {
+        wordSpacings.push(null);
+        return;
+      }
+
+      // must re-use font-size, even though it was removed above.
+      $line.css('font-size', fontSizes[lineNumber] + 'px');
+
+      for(var m=1, n=3; m<n; m+=interval) {
+        maxWordSpacing = testLineDimensions($line, maxWidth, 'word-spacing', m, interval, 'px', maxWordSpacing);
+        if(typeof maxWordSpacing !== 'number') {
+          wordSpacing = maxWordSpacing.size;
+          break;
+        }
+      }
+
+      $line.css('font-size', '');
+      wordSpacings.push(wordSpacing);
+    }).removeAttr('style');
+
+    if( !BigText.DEBUG_MODE ) {
+      $c.remove();
+    } else {
+      $c.css({
+        'background-color': 'rgba(255,255,255,.4)'
+      });
+    }
+
+    return {
+      fontSizes: fontSizes,
+      wordSpacings: wordSpacings,
+      ratios: ratios,
+      minFontSizes: minFontSizes
+    };
+  }
+
+  $.fn.bigtext = BigText.jQueryMethod;
+  window.BigText = BigText;
+
+})(this, jQuery);

data/bigtextjs_rails.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bigtextjs_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bigtextjs_rails"
+  spec.version       = BigtextjsRails::VERSION
+  spec.authors       = ["Guy Israeli"]
+  spec.description   = %q{This is an asset pipeline wrapper for the awesome bigtext.js}
+  spec.summary       = %q{BigText Makes Text Big. This gem will help you do it the rails way.}
+  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_dependency "railties", ">= 3.1"
+
+end

data/lib/bigtextjs_rails/version.rb

@@ -0,0 +1,3 @@
+module BigtextjsRails
+  VERSION = "0.1.4"
+end

data/lib/bigtextjs_rails.rb

@@ -0,0 +1,8 @@
+require "bigtextjs_rails/version"
+
+module BigtextjsRails
+ module Rails
+  class Engine < ::Rails::Engine
+  end
+ end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: bigtextjs_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+  prerelease: 
+platform: ruby
+authors:
+- Guy Israeli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: This is an asset pipeline wrapper for the awesome bigtext.js
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/bigtext.js
+- bigtextjs_rails.gemspec
+- lib/bigtextjs_rails.rb
+- lib/bigtextjs_rails/version.rb
+homepage: ''
+licenses:
+- MIT
+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: BigText Makes Text Big. This gem will help you do it the rails way.
+test_files: []