scheduled_resource 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 318a50d7695cf7ce846a78ccb22a41ef8aed0451
+  data.tar.gz: 4efe3c0200deefd46219b4fe1096478922493fbb
+SHA512:
+  metadata.gz: 723748c0c600788fc3283f335a208db385a4343659d2d3a1e04a7fcc8bddf268b53c9ef5df30f19dc02bfb39161831a28c8feaa6bffb4f8ed2f2844833ae0c34
+  data.tar.gz: c08da4242b8d12d4d0e56f9fb2c7c7c82e021e381b73b9c6298c9d93d3660d2da8792b3239d257d0b7e46268b08ed8555f78b80db5b9854532a201df24886be0

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 emeyekayee (Mike Cannon)
+
+The MIT License (MIT)
+
+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,136 @@
+#ScheduledResource
+
+This gem is for displaying how things are used
+over time -- a schedule for a set of resources.  It
+provides a way to describe what is being displayed,
+along with utilities and protocols to connect them:
+
+ - Configuration (specification and management),
+ - Query interfaces (a REST-like API and internal protocols to query the models), and
+ - A basic Rails controller implementation.
+
+So we have a way to configure the schedule, internal
+methods to generate the data, and a way to retrieve
+data from the client.  But the gem is largely
+view-framework agnostic.  We could use a variety of
+client-side packages or even more traditional Rails
+view templates to generate HTML.
+
+In any case, to get a the most from a display like this
+we need some client-side code.  The gem includes
+client-side modules to:
+
+ - Manage <b>time and display geometries</b> with "infinite" scroll along the time axis.
+ - <b>Format display cells</b> in ways specific to the resource models.
+ - <b>Update text justification</b> as the display is scrolled horizontally.
+
+
+## Configuration Management
+
+A **scheduled resource** is something that can be
+used for one thing at a time.  Say "Rocky & Bullwinkle"
+is on channel 3 from 10am to 11am on Saturday.  Then
+'channel 3' is the <u>resource</u> and that showing of
+the is a <u>resource-use block</u>.  Resources and 
+use-blocks are typically Rails models.  Each resource
+and its use-blocks get one row in the display.  That
+row has a label to the left with some timespan visible
+on the rest of the row.
+
+The <b>ScheduledResource</b> class manages resource and
+use-block class names, id's and labels for a schedule.
+A ScheduledResource instance ties together:
+
+ 1. A resource class (eg TvStation),
+ 2. An id (a channel number in this example), and
+ 3. Strings and other assets that will go into the DOM.
+
+The id is used to
+  - select a resource <em>instance</em> and
+  - select instances of the <em>resource use block</em> class (eg Program instances).
+
+The id <em>could</em> be a database id but more
+often is something a little more suited to human use
+in the configuration.  In any case it is used by model
+class method
+<tt>(resource_use_block_class).get_all_blocks()</tt>
+to select the right use-blocks for the resource.
+A resource class name and id are are joined with
+a '_' to form a tag that also serves as an id for the DOM.
+
+Something else you would expect see in a schedule
+would be headers and labels -- perhaps one row with
+the date and another row with the hour.  Headers and
+labels also fit the model of resources and use_blocks.
+Basic timezone-aware classes (ZTime*) for those are
+included in this gem.
+
+
+### Configuration File
+
+The schedule configuration comes from
+<tt>config/resource_schedule.yml</tt> which has
+three top-level sections:
+
+- ResourceKinds:  A hash where the key is a Resource and the value is a UseBlock. (Both are class names),
+- Resources:  A list where each item is a Resource Class followed by one or more resource ids, and
+- visibleTime:  The visible timespan of the schedule in seconds.
+
+The example file <tt>config/resource_schedule.yml</tt>
+(installed when you run <tt>schedulize</tt>) should be
+enough to display a two-row schedule with just the date
+above and the hour below.  Of course you can monkey-patch
+or subclass these classes for your own needs.
+
+
+### The schedule API
+
+The endpoint uses parameters <tt>t1</tt> and
+<tt>t2</tt> to specify a time interval for the request.
+A third parameter <tt>inc</tt> allows an initial time
+window to be expanded without repeating blocks that
+span those boundaries.  The time parameters _plus the
+configured resources_ define the data to be returned.
+
+
+### More About Configuration Management
+
+Once the configuration yaml is loaded that data is
+maintained in the session structure.  Of course having
+a single configuration file limits the application's
+usefulness.  A more general approach would be to
+have a user model with login and configuration would
+be associated with the user.
+
+
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'scheduled_resource'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scheduled_resource
+
+## Usage
+
+To Do: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/emeyekayee/scheduled_resource/fork )
+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 a new Pull Request

data/Rakefile

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

data/bin/schedulize

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+
+# This file is based heavily on Capistrano's `capify` command
+
+require 'optparse'
+require 'fileutils'
+
+def place_file( base, file, content )
+  file = File.join(base, file)
+  if File.exists?(file)
+    warn "[skip] `#{file}' already exists"
+  elsif File.exists?(file.downcase)
+    warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
+  elsif !File.exists?(File.dirname(file))
+    warn "[skip] directory `#{File.dirname(file)}' does not exist"
+  else
+    puts "[add] writing `#{file}'"
+    File.open(file, "w") { |f| f.write(content) }
+  end
+end
+
+def js_files_to_copy
+  dir = File.expand_path('../../lib/assets/javascripts' , __FILE__)
+  Dir[ dir + "/*" ]
+end
+
+def css_files_to_copy
+  dir = File.expand_path('../../lib/assets/stylesheets' , __FILE__)
+  Dir[ dir + "/*" ]
+end
+
+def to_js_dir(base)   File.join base, 'vendor/assets/javascripts' end
+def to_css_dir(base)  File.join base, 'vendor/assets/stylesheets' end
+def js_manifest(base) File.join base, 'app/assets/javascripts/application.js' end
+def css_manifest(base) File.join base, 'app/assets/stylesheets/application.css' end
+
+def js_require_content
+  <<EOF
+//= require use_block
+//= require time_pix
+//= require justify_tweaks
+EOF
+end
+
+def insert_js_requires( file )
+  manifest_lines = IO.readlines( file )
+  ix = manifest_lines.rindex{|l| l =~ %r[^//= require.+(jquery|angular)] }
+
+  manifest_lines[ix] << js_require_content
+  puts "[modify] writing `#{file}'"
+  File.open(file, "w") { |f| f.write( manifest_lines.join ) }
+rescue Exception => e
+  puts "Failed to edit file #{file};\n#{e}; continuing..."
+  puts "Be sure these js dependencies are handled:\n#{js_require_content}\n\n"
+end
+
+def css_require_content
+  <<EOF
+ *= require scheduled_resource
+EOF
+end
+
+def insert_css_requires( file )
+  manifest_lines = IO.readlines( file )
+  ix = manifest_lines.index{|l| l =~ %r[^ *\*= require] }
+
+  manifest_lines[ix] = css_require_content + manifest_lines[ix]
+  puts "[modify] writing `#{file}'"
+  File.open(file, "w") { |f| f.write( manifest_lines.join ) }
+rescue Exception => e
+  puts "Failed to edit file #{file};\n#{e}; continuing..."
+  puts "Be sure these css dependencies are handled:\n#{css_require_content}\n\n"
+end
+
+
+PROGRAM = File.basename($0)
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{PROGRAM} [path]"
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+unless ARGV.empty?
+  if !File.exists?(ARGV.first)
+    abort "`#{ARGV.first}' does not exist."
+  elsif !File.directory?(ARGV.first)
+    abort "`#{ARGV.first}' is not a directory."
+  elsif ARGV.length > 1
+    abort "Too many arguments; please specify only the directory to wheneverize."
+  end
+end
+
+base = ARGV.empty? ? '.' : ARGV.shift
+
+FileUtils.cp   js_files_to_copy, to_js_dir(base)
+FileUtils.cd( to_js_dir(base) ) do
+  FileUtils.cp  "blank.jpg",  "Day.jpg"
+  FileUtils.cp  "blank.jpg", "Hour.jpg"
+end
+
+FileUtils.cp  css_files_to_copy, to_css_dir(base)
+
+insert_js_requires   js_manifest(base)
+insert_css_requires css_manifest(base)
+
+
+config_content = %q{
+# Configuration file for ScheduledResource schedule widget.
+#
+
+# Classes that represent a resource and resource-use pair.
+ResourceKinds:
+# Resource:             Resource Use
+  ZTimeHeaderDay:       ZTimeLabelDay
+  ZTimeHeaderHour:      ZTimeLabelHour
+
+# Other examples:
+# ConferenceRoom:       Meeting
+# TvStation:            ProgramEvent
+
+# The schedule display sizes itself to the page width.  What span
+# of time should this be in seconds?  (Value string is eval'd)
+visibleTime: 3.hours
+
+# A row in the display is specified by a pair: (Resource_class, Resource_id)
+# The Resource_id is given as a string to be interpreted by the specific
+# classes.  For the included ZTime* classes the Resource_id (rid) indicates
+# the timezone, [-8 .. -5] represent Pacific .. Eastern US timezones.
+Resources:
+   - ZTimeHeaderDay       -8
+   - ZTimeHeaderHour      -8
+   - ZTimeHeaderDay       -5
+   - ZTimeHeaderHour      -5
+}
+
+place_file( base, 'config/resource_schedule.yml', config_content)
+
+
+
+controller_content = <<-CONTROLLER
+# Needed this here to get the ZTime* classes in time for session.
+require 'scheduled_resource'
+
+class ScheduleController < ApplicationController
+  include ScheduledResource::Helper
+
+  before_action :ensure_schedule_config
+
+
+  # Returns angularjs page (template) which in turn fetches data.
+  def index
+  end
+
+
+  # Json data.
+  def schedule
+    get_data_for_time_span
+
+    render json: @blockss
+  end
+
+end
+CONTROLLER
+
+place_file( base, 'app/controllers/schedule_controller.rb', controller_content)
+

data/lib/assets/javascripts/justify_tweaks.js

@@ -0,0 +1,186 @@
+'use strict';
+
+// ============================================================================
+// Hi-lock: ((" ?[T]o ?Do:.*"                                  (0 'accent10 t)))
+// Hi-lock: (("\\(^\\|\\W\\)\\*\\(\\w.*\\w\\)\\*\\(\\W\\|$\\)" (2 'accent3 t)))
+// Hi-lock: end
+// ============================================================================
+
+// The idea here is to have *smooth* horizontal scrolling for a mobile device,
+// track-pad or touch-sensitive mouse like Apple's.  It makes navigating a
+// time-window feel much more natural.
+//
+// If you have text within the scrolled content you may want to re-justify that
+// text for readability as it scrolls left or right.
+//
+// This is one approach that avoids the jerkiness associated with a normal
+// scroll event-listener.  The idea is just to wait for the scroll position to
+// stabilize, recalculate the visible parts of each container, then animate
+// changes to the '.text_locator' with a little randomness thrown in.
+
+// ToDo: Convert this to an object w/ methods, for better encapsulation.
+ 
+// Sole exported function: 
+function filter_justify_tweaks(sc) {
+  var scrollLeft  = sc.scrollLeft()
+
+  // Don't repeat the calculation unnecessarily....
+  if ( filter_justify_tweaks.old_srcoll == scrollLeft ) return
+  filter_justify_tweaks.old_srcoll = scrollLeft 
+
+  do_justify_tweaks( sc, scrollLeft )
+}
+
+
+function do_justify_tweaks (sc, scrollLeft) {
+  $('.ZTimeHeaderDayrow .timespan').each( function() { // Centered
+    justify( scrollLeft, $(this).children() )
+  });
+
+  $('.Stationrow .timespan').each( function() {        // Left-aligned
+    justify_left( scrollLeft, $(this).children() )
+  });
+
+}
+
+
+function may_straddle (scrollLeft, scrollRight, blockdivs) {
+  var divs = [], bdiv, cd;
+  var len = blockdivs.length;
+
+  for (var i = 0;
+       (i<len) && (cd = common_data(blockdivs[i])) && cd.bdiv_right < scrollLeft;
+       i++) {}
+
+  for (;
+       (i<len) && (bdiv= blockdivs[i]) && parseInt(bdiv.style.left) < scrollRight;
+       i++) {
+    divs.push( bdiv )
+  }
+  return divs
+}
+
+// function sort_em (divs) {
+//   divs.sort( function(a, b) {
+//     return parseInt(a.style.left) - parseInt(b.style.left)
+//   })
+// }
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Re-align left-aligned block content (typ. Channelrows)
+
+function justify_left (scrollLeft, blockdivs) {
+  // sort_em( blockdivs )
+
+  var scrollRight = scrollLeft + TimePix.pixWindow,
+      bdivs       = may_straddle (scrollLeft, scrollRight, blockdivs);
+  if (! bdivs.length) {return}
+
+  var cd = common_data( bdivs[0] )
+  if ( cd.bdiv_left < scrollLeft  ) {
+    bdivs.shift()
+    justify_left_1 ( scrollLeft,  cd );
+  }
+  undo_any_justify_left( bdivs );
+}
+
+function justify_left_1 ( scrollLeft, cd ) {
+  if ( cd.bdiv_left + cd.bdiv_width > scrollLeft ) {
+    var jleft  = scrollLeft - cd.bdiv_left
+
+    // cd.tl.css('left', jleft + 'px')
+    cd.tl.animate({left: jleft}, rand_speed())
+  }
+}
+
+function undo_any_justify_left (bdivs) {
+  bdivs.forEach( function( bdiv ) {
+    // $('.text_locator', bdiv).css( 'left', '')
+    var tl = $('.text_locator', bdiv)
+    if ( parseInt(tl.css('left')) == 2 ) {return}
+    tl.animate({ left: "2" }, rand_speed())
+  })
+}
+
+function rand_speed() { return { duration: 200 + Math.random() * 800 } }
+
+//////////////////////////////////////////////////////////////////////////////
+// Re-align center-aligned block content.
+
+function justify (scrollLeft, blockdivs) {
+  // sort_em(blockdivs)
+  var scrollRight = scrollLeft + TimePix.pixWindow,
+      bdivs       = may_straddle (scrollLeft, scrollRight, blockdivs);
+  if (! bdivs.length) {return}
+
+
+  if ( straddles(scrollLeft, bdivs[0]) && straddles(scrollRight, bdivs[0]) ) {
+    straddles_both( scrollLeft, scrollRight, common_data(bdivs[0]) )
+  } else {
+
+    while ( bdivs.length > 0 && straddles( scrollLeft, bdivs[0] ) ) {
+      straddles_left  (scrollLeft,  common_data(bdivs.shift()));
+    }
+
+    while ( bdivs.length > 0 && straddles( scrollRight, bdivs.slice(-1)[0] ) ) {
+      straddles_right( scrollRight, common_data(bdivs.pop()) );
+    }
+
+    bdivs.forEach( function(bdiv) {
+      straddles_none(               common_data(bdiv));
+    })
+  }
+}
+
+function straddles(edge, bdiv) {
+  var cd = common_data( bdiv )
+  return ( cd.bdiv_left < edge && edge < cd.bdiv_right )
+}
+
+function common_data(bdiv) {
+  var left  = parseInt(bdiv.style.left)
+  var width = parseInt(bdiv.style.width)
+  return { tl:         $('.text_locator', bdiv),
+           bdiv_left:  left,
+           bdiv_width: width,
+           bdiv_right: left + width }
+}
+
+function straddles_both (scrollLeft, scrollRight, cd) {
+  var  nleft = scrollLeft  - cd.bdiv_left
+  var nwidth = scrollRight - scrollLeft
+  relocate (cd.tl,  nleft, nwidth)
+}
+
+function straddles_right (scrollRight, cd) {
+  if ( cd.bdiv_left + cd.bdiv_width > scrollRight ) {
+    var room = scrollRight - parseInt( cd.tl.parent().css('left') )
+    var jwidth = Math.max( room, 190 ) // 15 in vp
+    relocate (cd.tl,     0, jwidth)
+  }
+}
+
+function straddles_left (scrollLeft, cd) {
+  if ( cd.bdiv_left + cd.bdiv_width > scrollLeft ) {
+    var room = parseInt( cd.tl.parent().css('width') )
+    var jleft  = Math.min (scrollLeft - cd.bdiv_left, room - 190 ) // 15 in vp
+    var jwidth = room - jleft           // Should calculate  ^^^ this Fix Me
+    relocate (cd.tl, jleft, jwidth)
+  }
+}
+
+function straddles_none(cd) {
+  var room = parseInt( cd.tl.parent().css('width') )
+  if ( parseInt(cd.tl.css('left'))  != 0 ||
+       parseInt(cd.tl.css('width')) != room ) {
+    relocate (cd.tl,    0, room)
+  }
+}
+
+
+function relocate (tl, nleft, nwidth) {
+  tl.animate({opacity: 0}, {queue: true, duration: 200})
+  tl.animate({ left: nleft, width: nwidth}, {queue: true, duration: 0})
+  tl.animate({opacity: 1}, {queue: true, duration: 800})
+}