modularity-coffee-rails 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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,163 @@
+# Modularity::Rails [![Build Status](https://secure.travis-ci.org/kevgo/modularity-rails.png)](http://travis-ci.org/#!/kevgo/modularity-rails) <a href="https://codeclimate.com/github/kevgo/modularity-rails" target="_blank"><img src="https://codeclimate.com/badge.png" /></a>
+
+Makes the [Modularity CoffeeScript](http://github.com/kevgo/modularity-coffeescript) library and related modules available to
+Rails 3.1 applications.
+
+Modularity is a framework for lightweight component-oriented CoffeeScript.
+It allows to compose functionally rich web pages in a clean, intuitive, and testable way
+out of well structured and reusable components. It scales very well with complexity.
+
+
+## Authors
+* [Kevin Goslar](https://github.com/kevgo) (kevin.goslar@gmail.com)
+* [Alex David](https://github.com/alexdavid)
+
+
+# Installation
+
+Load modularity in your application's Gemfile:
+
+```ruby
+gem 'modularity-rails'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Finally, you have to load the modularity file into your application's javascript.
+The easiest way is to add it to `application.coffee`:
+
+```coffeescript
+ # require jquery
+ # require modularity
+```
+
+
+# Usage
+
+Modularity is a lightweight framework for building powerful AJAX applications.
+Modularity avoids magic and heavyness. It focusses on providing a pragmatic and interoperable foundation
+for clean hand-written code bases.
+Modularity provides practices to create code bases of incredible complexity that are still
+nicely manageable and perform very well.
+
+
+## Modules
+
+Modules are native CoffeeScript classes that are specialized for doing what most JavaScript running in browsers does:
+managing a UI consisting of DOM elements, reacting to events that happen within that section,
+representing application logic specific to that section, and providing high-level APIs for others to interact with the section.
+
+Each module has a container. The container is the outermost DOM element of a section.
+Everything the module does must happen inside this container.
+The module is responsible for managing the inner DOM-structure of the container.
+
+
+## Mixins
+
+Similar to Ruby mixins, mixins in Modularity allow to include orthogonal functional aspects defined in separate objects into a class.
+
+```coffeescript
+myMixin =
+
+  # This will be called when an instance of a class that includes this mixin is created.
+  constructor: ->
+
+  # This method will be available in every class that includes
+  myMethod: ->
+
+
+class MyModule extends Module
+
+  @mixin myMixin
+
+  constructor: (container) ->
+
+    # The super constructor will call the mixin constructors here.
+    super
+
+    # ...
+```
+
+## Hooks
+
+Hooks are a more direct and easier way to interact with mixins. They are methods with predefined names that mixing modules can implement to hook into events of their mixins
+without the need to wire up event handlers, and with the ability to interact with the workflow of the mixins.
+
+
+# Reusable example modules and mixins.
+
+Modularity comes bundled with a bunch of example modules and mixins that can be used in production code.
+The example modules are located in `vendor/assets/javascripts/modules/` and _vendor/assets/javascripts/mixins_
+and must be explicitly required in your Rails files using the `require` commands of the asset pipeline.
+
+
+## Modules
+
+* __button.coffee__: A simple button. Fires the `clicked` event when anything inside the container is clicked. Uses the `clickable` mixin.
+* __counter_button.coffee__: Similar to button, but includes the click count as data payload in the fired event.
+
+
+## Mixins
+
+###clickable
+Including this mixins adds a 'clickable' aspect to your module, i.e. turns it into a button. Clicking anywhere inside the container makes it fire the 'clicked' event.
+
+###closable
+Including this mixin makes a module closable. The mixin searches for an embedded DOM element with the class 'CloseButton'. When it is clicked, the following things happen:
+
+* The _closable_closing_ hook of the closable class is called.
+  This hook could be used to display confirmation dialogs (and abort the close process) or to fire custom events that depend on the DOM still being present.
+  If this method returns a falsy value, the closing process is aborted.
+* The closable module fires a local 'closing' event (with the DOM still present).
+* The whole module including its container is removed from the DOM.
+* The _closable_closed_ hook of the closable class is called.
+
+
+## Tools
+
+### Loader
+A generic cached loader for parallel and repeated GET requests.
+Prevents duplicate requests, caches the responses.
+
+The first request triggers the ajax request. Subsequent requests while the resquest is running are accumulated without causing new requests.
+Once the response arrives, all currently requesting clients are answered. Subsequent requests are answered immediately using the cached data.
+
+```coffeescript
+Module.loader.get '/test.json', (data) ->
+  # Use data here.
+```
+
+# Development
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Running the unit tests
+
+```bash
+$ evergreen run
+```
+
+
+## Automatically refreshing the browser during development.
+
+Modularity-Rails comes with support for [LifeReload](https://github.com/mockko/livereload) via [Guard](https://github.com/guard/guard).
+
+* Install the LiveReload browser extension: [Chrome](https://chrome.google.com/webstore/detail/jnihajbhpnppcggbcgedagnkighmdlei)
+* Run the evergreen server: ```$ evergreen run```
+* Run the guard server: ``` $ bundle exec guard ```
+* Start the LiveReload plugin in Chrome (button in address bar).
+* Navigate to the test page that you want to observe.
+* Change and save code and see the browser reload.
+
+

data/Rakefile

@@ -0,0 +1,31 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ModularityCoffeeRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new :spec
+task :default => :spec
+

data/app/assets/javascripts/modularity/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require ./modularity
+//= require_tree .

data/app/assets/javascripts/modularity/data/ajax_loader.coffee

@@ -0,0 +1,77 @@
+#= require modularity/data/cache
+
+
+# A generic ajax loader for parallel GET requests.
+# Prevents duplicate requests, caches the responses
+# to answer subsequent requests immediately
+# without additional server requests.
+#
+# Warning: Caches the responses, so once a request is cached,
+#          any new content on the same URL will not be visible!
+class window.modularity.AjaxLoader
+
+  constructor: (params = {}) ->
+
+    # Caches the callbacks.
+    @cb_cache = new modularity.Cache()
+
+    # Whether to perform caching of data.
+    # Default: no.
+    @caching = !!params.caching
+
+    # Caches the data loaded.
+    @data_cache = new modularity.Cache()
+
+    # The number of currently running loading operations.
+    @loader_count = 0
+
+
+  # The different events that this class can fire.
+  @events =
+    AJAX_LOADING: 'AJAX_LOADING'
+    AJAX_LOADED: 'AJAX_LOADED'
+
+
+  # Loads the data from the given URL asynchronously.
+  get: (url, callback) ->
+
+    # Return immediately if we have cached data.
+    if @caching
+      cached_data = @data_cache.get url
+      return callback(cached_data) if cached_data?
+
+    # Here, we have no cached data. Check
+
+    # If a GET call to this URL is already in progress -->
+    # add the given callback to the list of waiting callbacks.
+    request_in_progress = @cb_cache.get url
+    return request_in_progress.push(callback) if request_in_progress?
+
+    # Here, no request is currently in progress --> start a new one.
+
+    # Add callback to callback list.
+    @cb_cache.add url, [callback]
+
+    # Fire 'loading' event if this is the start of a loading operation.
+    @loader_count++
+    if @loader_count == 1
+      window.modularity.fire_global_event window.modularity.AjaxLoader.events.AJAX_LOADING
+
+    # Perform the request.
+    jQuery.get url, (data) =>
+
+      # Add result to cache.
+      if @caching
+        @data_cache.add url, data
+
+      # Call callbacks.
+      cb(data) for cb in @cb_cache.get url
+
+      # Remove request from callback list.
+      @cb_cache.remove url
+
+      # Fire 'loaded' event.
+      @loader_count--
+      if @loader_count == 0
+        window.modularity.fire_global_event window.modularity.AjaxLoader.events.AJAX_LOADED
+

data/app/assets/javascripts/modularity/data/cache.coffee

@@ -0,0 +1,63 @@
+#= require modularity/tools/object_tools
+
+# A generic cache.
+# Stores key-value pairs.
+class window.modularity.Cache
+
+  constructor: ->
+    @cache = {}
+
+
+  # Adds the given entry to the cache.
+  # Overwrites existing entries.
+  add: (key, value) ->
+    @cache[key] = value
+
+
+  # Returns the entry with the given key from the cache, or NULL if no entry exists.
+  get: (key) ->
+    @cache[key]
+
+
+  # Looks up several entries at once.
+  # Returns a hash of found entries, and a list of missing entries.
+  get_many: (keys) ->
+    result = { found: {}, missing: [] }
+    for key in keys
+      do (key) =>
+        value = @cache[key]
+        if value
+          result.found[key] = value
+        else
+          result.missing.push key
+    result
+  getMany: Cache::get_many
+
+
+  # Returns the number of cached objects.
+  length: () ->
+    modularity.object_length @cache
+
+
+  # Removes the entry with the given key.
+  remove: (key) =>
+    delete @cache[key]
+
+
+  # Removes all entries with the given keys.
+  remove_many: (keys) ->
+    @remove(key) for key in keys
+
+
+  # Replaces the cache with the given data.
+  # When 'key' is given, treats 'data' as an array of objects, and indexes each element by the given key.
+  # When 'key' is not given, treats 'data' as an already indexed hash object.
+  replace_all: (data, key) ->
+    if key
+      # Key given --> index the data array.
+      @add(entry[key], entry) for entry in data
+    else
+      # Key not given --> use data as the new cache.
+      @cache = data
+  replaceAll: Cache::replace_all
+

data/app/assets/javascripts/modularity/data/indexed_cache.coffee

@@ -0,0 +1,32 @@
+#= require modularity/data/cache
+
+# Provides fast and convenient retrieval of hash objects
+# by indexing them on a given key column.
+class modularity.IndexedCache
+
+  constructor: (@key) ->
+    @cache = new modularity.Cache
+
+
+  add: (entry) ->
+    @cache.add entry[@key], entry
+
+
+  add_all: (entries) ->
+    @add(entry) for entry in entries
+
+
+  remove: (entry) ->
+    @cache.remove entry[@key]
+
+
+  remove_many: (entries) ->
+    @cache.remove_many entries
+
+
+  get: (key) ->
+    @cache.get key
+
+
+  length: => @cache.length()
+

data/app/assets/javascripts/modularity/data/persistence_manager.coffee

@@ -0,0 +1,166 @@
+#= require modularity/data/ajax_loader
+#= require modularity/data/indexed_cache
+#= require modularity/tools/object_tools
+
+# Provides persistence services for data models.
+class modularity.PersistenceManager
+
+  constructor: (params) ->
+
+    # Copy of the data as it is on the server.
+    @server_data = new modularity.IndexedCache 'id'
+
+    # Copy of the data as it is on the client.
+    @client_data = new modularity.IndexedCache 'id'
+
+    # The base url on the server. Expected to be a fully RESTful API.
+    @base_url = params.url
+
+    @key = params.key or 'id'
+
+    # For handling parallel requests to the server.
+    @loader = new modularity.AjaxLoader { cache: no }
+
+
+  # Adds the given data objects to the server cache.
+  add_all: (data) ->
+    @server_data.add_all data
+
+
+  # Returns the URL to access the collection of objects.
+  collection_url: ->
+    "#{@base_url}.json"
+
+
+  # Creates the given object on the server.
+  create: (obj, callback) ->
+    jQuery.ajax
+      url: @collection_url()
+      type: 'POST'
+      data: obj
+      success: (server_obj) =>
+        @server_data.add server_obj
+        callback server_obj
+
+
+  delete: (obj, callback) ->
+    @client_data.remove obj
+    @server_data.remove obj
+    jQuery.ajax
+      url: @entry_url(obj)
+      type: 'DELETE'
+      success: ->
+        callback() if callback?
+
+
+  delete_many: (objects, callback) ->
+    @client_data.remove_many obj
+    @server_data.remove_many obj
+    jQuery.ajax
+      url: @base_url
+      type: 'DELETE'
+      data: (obj.id for obj in objects)
+      success: ->
+        callback() if callback?
+
+
+  # Returns the url to access a single entry.
+  entry_url: (entry) ->
+    "#{@base_url}/#{entry[@key]}.json"
+
+
+  # Returns the cached data object, or undefined.
+  get_cached: (key) ->
+
+    # Try to use client_data cache.
+    client_obj = @client_data.get key
+    return client_obj if client_obj
+
+    # No data in client cache --> try to use server cache.
+    server_obj = @server_data.get key
+    if server_obj
+      client_obj = modularity.clone_hash server_obj
+      @client_data.add client_obj
+      return client_obj
+
+    # Object not found in client or server cache.
+    return undefined
+
+
+  # Returns the entry with the given key.
+  load: (key, callback) ->
+
+    # Try to load from cache.
+    return callback(snippet) if snippet = @get_cached key
+
+    # No data on client at all --> load data from server.
+    @loader.get "#{@base_url}/#{key}", (server_entry) =>
+      @server_data.add server_entry
+      client_entry = modularity.clone_hash server_entry
+      @client_data.add client_entry
+      callback client_entry
+
+
+  # Loads all objects from the server.
+  # Provides the given params as parameters to the GET request.
+  load_all: (callback, params) ->
+    jQuery.ajax
+      url: @collection_url()
+      cache: no
+      data: params
+      success: (data) =>
+        @server_data.add_all data
+        callback()
+
+
+  # Loads all snippets with the given ids.
+  load_many: (ids, callback) ->
+    missing_ids = []
+    snippets = []
+    $.each ids, (pos, id) =>
+      snippet = @get_cached id
+      if snippet
+        snippets.push snippet
+      else
+        missing_ids.push id
+
+    if missing_ids.length == 0
+      return callback(snippets)
+
+    alert "uncached snippets found: #{missing_ids}"
+
+
+  # Saves the given object.
+  # Does the right thing (create or update) dependent on
+  # whether the object already has a key parameter.
+  save: (obj, callback) ->
+    if obj[@key]?
+      @update obj, callback
+    else
+      @create obj, callback
+
+
+  # Updates the given object.
+  # The given object must exist on the server already,
+  # and have a proper value in the key attribute.
+  update: (obj, callback) ->
+
+    # Create a new hash, containing only the changed attributes between obj and it's replica in @server_data.
+    diff_obj = modularity.object_diff @server_data.get(obj[@key]), obj
+    return if modularity.object_length(diff_obj) == 0
+
+    # Add key attribute.
+    diff_obj[@key] = obj[@key]
+
+    # Update server_data version.
+    @server_data.add obj
+
+    # Send to server
+    jQuery.ajax
+      url: @entry_url(obj)
+      type: 'PUT'
+      data: diff_obj
+      success: (server_obj) =>
+        @server_data.add server_obj
+        callback server_obj if callback
+

data/app/assets/javascripts/modularity/mixins/clickable.coffee

@@ -0,0 +1,21 @@
+# This mixin adds a 'clickable' aspect to modules.
+# This means clicking anywhere on the module fires the 'clicked' event.
+window.modularity.clickable =
+
+  constructor: ->
+    @container.click @container_clicked
+
+
+  # Events that are fired by this mixin.
+  events:
+    clicked: 'clicked'
+
+
+  # Programmatically click this clickable element.
+  # For testing and scripting.
+  click: -> @container.click()
+
+
+  # Event handler for clicks on this clickable element.
+  container_clicked: -> @fire_event modularity.clickable.events.clicked
+

data/app/assets/javascripts/modularity/mixins/closable.coffee

@@ -0,0 +1,21 @@
+window.modularity.closable =
+
+  constructor: (container) ->
+    close_button = @container.find('.CloseButton')
+    unless close_button?.length > 0
+      window.alert 'Error: Close button not found'
+    close_button.click => @close_button_clicked()
+
+
+  # The events that can be fired by closable objects.
+  events:
+    closed: 'closed'
+
+
+  # Called when the button got clicked by the user or programmatically.
+  close_button_clicked: ->
+    if @closable_closing
+      return unless @closable_closing()
+    @fire_event 'closed'
+    @container.remove()
+    @closable_closed() if @closable_closed

data/app/assets/javascripts/modularity/modularity.coffee

@@ -0,0 +1,128 @@
+# The Modularity framework written specificially for CoffeeScript.
+#
+# Use UglifyJS (http://github.com/mishoo/UglifyJS) for compression.
+#
+# Please see https://github.com/kevgo/modularity for more information on Modularity,
+# and https://github.com/kevgo/modularity-rails for Rails integration.
+
+
+window.modularity = {
+
+  # Checks whether the given condition is true.
+  # Shows an alert with the given message if not.
+  assert: (condition, message) ->
+    if !condition or condition?.length == 0
+      alert message
+      return false
+    true
+
+
+  # GLOBAL EVENTS.
+
+  # Subscribes to the given global event,
+  # i.e. calls the given function when the given global event type happens.
+  bind_global_event: (event_type, callback) ->
+    return unless modularity.assert typeof event_type == 'string', "modularity.bind_global_event: parameter 'event_type' is empty"
+    return alert "modularity.bind_global_event: parameter 'callback' must be a function, #{callback} (#{typeof callback}) given." unless typeof callback == 'function'
+    modularity.global_event_container().bind event_type, callback
+
+  # Fires the given global event with the given data payload.
+  fire_global_event: (event_type, data) ->
+    modularity.assert event_type, 'Module.fire_global_event: You must provide the event type to fire.'
+    return alert("Module.fire_global_event: Event type must be a string, #{event_type} (#{typeof event_type}) given.") unless typeof event_type == 'string'
+    modularity.global_event_container().trigger event_type, data ?= []
+
+  # Returns the DOM object that is used to fire global events on.
+  global_event_container: -> modularity.global_event_container_cache or= $(window)
+}
+window.modularity.bindGlobalEvent = window.modularity.bind_global_event
+window.modularity.fireGlobalEvent = window.modularity.fire_global_event
+
+
+class window.modularity.Module
+
+  # The container variable is required. Provide 'testing' in tests.
+  constructor: (container) ->
+    container = $(container) if (typeof container == 'string') and container != 'testing'
+    @container = container
+
+    return alert 'Error in Module constructor: No container given.' unless @container?
+    if container != 'testing'
+      return alert 'Error in Module constructor: The given container must be a jQuery object.' unless typeof container.jquery == 'string'
+      return alert "Error in Module constructor: The given container ('#{container.selector}') is empty." unless container? and container.length > 0
+      return alert "Error in Module constructor: The given container ('#{container.selector}') has more than one element." unless container? and container.length == 1
+
+
+    # Attach mixins.
+    if @mixins?
+      for mixin_data in @mixins
+
+        # Attach all properties from mixin to the prototype.
+        for methodName, method of mixin_data.mixin
+          do (methodName, method) => unless @[methodName]
+            @[methodName] = => method.apply(@, arguments)
+
+        # Call constructor function from mixin.
+        mixin_data.mixin?.constructor?.apply(@, arguments)
+
+
+  # Runs the given query within the container element.
+  $: (query) ->
+    @container.find query
+
+
+  # MODULE EVENTS.
+
+  # Calls the given function when this widget fires the given local event.
+  bind_event: (event_type, callback) =>
+    return unless modularity.assert typeof event_type == 'string', "Module.bind_event: parameter 'event_type' is empty"
+    return alert "Module.bind_event: parameter 'callback' must be a function, #{callback} (#{typeof callback}) given." unless typeof callback == 'function'
+    @container.bind event_type, callback
+  bindEvent: Module::bind_event
+
+  # Fires the given local event with the given data payload.
+  fire_event: (event_type, data) =>
+    modularity.assert event_type, 'Module.fire_event: You must provide the event type to fire.'
+    return alert("Module.fire_event: Event type must be a string, #{event_type} (#{typeof event_type}) given.") unless typeof event_type == 'string'
+    @container.trigger event_type, data ?= {}
+  fireEvent: Module::fire_event
+
+
+  # Hides this module.
+  hide: ->
+    @container.hide()
+
+
+  # mixin = constructor of Draggable
+  # self = Card
+  @mixin: (mixin, p...) ->
+    alert("mixin not found") unless mixin
+    @prototype.mixins or= []
+    @prototype.mixins.push({mixin: mixin, params: p})
+
+
+  # Shows this module.
+  show: ->
+    @container.show()
+
+
+# jQuery integration for creating Modules.
+#
+# Call like this: myModule = $('...').module(MyModuleClass)
+#
+# Parameters:
+# * klass: the class of the Module to instantiate
+# * any additional parameters are forwarded to the Module constructor.
+# Returns the created module instance.
+#
+# Messages errors in alert boxes.
+#
+jQuery.fn.module = (klass, args...) ->
+
+  # Check parameters.
+  if typeof klass != 'function'
+    return alert "ERROR!\n\nYou must provide the Module class when calling $.module().\n\nExample: $('...').module(MyModuleClass)\n\nYou provided: #{klass} (#{typeof klass})"
+
+  # Instantiate the class and return the instance.
+  new klass(this, args...)
+

data/app/assets/javascripts/modularity/modules/autogrow_textarea.coffee

@@ -0,0 +1,32 @@
+# Autogrowing textarea.
+class window.modularity.AutogrowTextArea extends modularity.Module
+
+  constructor: (container) ->
+    super
+    @textarea = @container[0]
+    @textarea.style.height = "auto"
+    @textarea.style.overflow = "hidden"
+    @container.keyup @grow
+    @container.focus @grow
+    @container.blur @grow
+
+    # How many characters per line.
+    @characters_per_line = this.textarea.cols
+
+    # The initial (minimal) number of rows.
+    @min_rows = this.textarea.rows
+
+    @grow()
+
+
+  # Sets the height of the textarea according to the content.
+  grow: =>
+    @textarea.rows = Math.max modularity.AutogrowTextArea.lines(@characters_per_line, @textarea.value), @min_rows
+
+  # Returns the number of lines
+  @lines: (width, text) ->
+    lines_count = 0
+    lines = text.split(/\n/)
+    lines_count += Math.floor((line.length / width) + 1) for line in lines
+    lines_count
+

data/app/assets/javascripts/modularity/modules/button.coffee

@@ -0,0 +1,8 @@
+#= require modularity/mixins/clickable
+
+# A button module.
+# Responds to clicks on the container element.
+# The container element is expected to already be populated.
+class window.modularity.Button extends window.modularity.Module
+  @mixin window.modularity.clickable
+

data/app/assets/javascripts/modularity/tools/array_tools.coffee

@@ -0,0 +1,6 @@
+# Returns a copy of the given array with duplicates removed.
+window.modularity.array_unique = (array) ->
+  output = {}
+  output[array[i]] = array[i] for i in [0...array.length]
+  value for key, value of output
+

data/app/assets/javascripts/modularity/tools/object_tools.coffee

@@ -0,0 +1,25 @@
+# Returns a replica of the given hash.
+# Don't use this method for real objects with superclasses, prototypes, and stuff.
+modularity.clone_hash = (obj) ->
+  result = {}
+  result[key] = value for own key, value of obj
+  result
+
+
+# Returns an object that contains only the attributes
+# that are different between obj_1 and obj_2.
+# Only looks for changed attributes, not missing attributes.
+modularity.object_diff = (obj_1, obj_2) ->
+  result = {}
+  for own key, value_2 of obj_2
+    do (key, value_2) ->
+      value_1 = obj_1[key]
+      result[key] = value_2 if value_1 != value_2
+  result
+
+
+# Returns the number of attributes of the given object.
+# NOTE(KG): This doesn't work in IE8.
+modularity.object_length = (obj) ->
+  Object.keys(obj).length
+

data/app/controllers/modularity-coffee-rails/application_controller.rb

@@ -0,0 +1,4 @@
+module ModularityCoffeeRails
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/modularity-coffee-rails/application_helper.rb

@@ -0,0 +1,4 @@
+module ModularityCoffeeRails
+  module ApplicationHelper
+  end
+end

data/app/views/layouts/modularity-coffee-rails/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>ModularityCoffeeRails</title>
+  <%= stylesheet_link_tag    "modularity-coffee-rails/application", :media => "all" %>
+  <%= javascript_include_tag "modularity-coffee-rails/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+ModularityCoffeeRails::Engine.routes.draw do
+end

data/lib/modularity-coffee-rails.rb

@@ -0,0 +1,4 @@
+require "modularity-coffee-rails/engine"
+
+module ModularityCoffeeRails
+end

data/lib/modularity-coffee-rails/engine.rb

@@ -0,0 +1,5 @@
+module ModularityCoffeeRails
+  class Engine < ::Rails::Engine
+    isolate_namespace ModularityCoffeeRails
+  end
+end

data/lib/modularity-coffee-rails/version.rb

@@ -0,0 +1,3 @@
+module ModularityCoffeeRails
+  VERSION = "0.0.1"
+end

data/lib/tasks/modularity-coffee-rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :modularity-coffee-rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: modularity-coffee-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kevin Goslar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+- !ruby/object:Gem::Dependency
+  name: coffee-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: konacha
+  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: rspec-rails
+  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: sqlite3
+  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'
+description: Makes the modularity-coffee framework available to Ruby on Rails applications.
+email:
+- kevin.goslar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/assets/javascripts/modularity/application.js
+- app/assets/javascripts/modularity/data/ajax_loader.coffee
+- app/assets/javascripts/modularity/data/cache.coffee
+- app/assets/javascripts/modularity/data/indexed_cache.coffee
+- app/assets/javascripts/modularity/data/persistence_manager.coffee
+- app/assets/javascripts/modularity/mixins/clickable.coffee
+- app/assets/javascripts/modularity/mixins/closable.coffee
+- app/assets/javascripts/modularity/modularity.coffee
+- app/assets/javascripts/modularity/modules/autogrow_textarea.coffee
+- app/assets/javascripts/modularity/modules/button.coffee
+- app/assets/javascripts/modularity/tools/array_tools.coffee
+- app/assets/javascripts/modularity/tools/object_tools.coffee
+- app/controllers/modularity-coffee-rails/application_controller.rb
+- app/helpers/modularity-coffee-rails/application_helper.rb
+- app/views/layouts/modularity-coffee-rails/application.html.erb
+- config/routes.rb
+- lib/modularity-coffee-rails/engine.rb
+- lib/modularity-coffee-rails/version.rb
+- lib/modularity-coffee-rails.rb
+- lib/tasks/modularity-coffee-rails_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: http://github.com/kevgo/modularity-rails
+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.23
+signing_key: 
+specification_version: 3
+summary: A lightweight, object- and component-oriented CoffeeScript framework for
+  Ruby on Rails applications.
+test_files: []