polished-knockout 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c60a918d9afb8c42b4b3727eaf288a89b5d834a8
+  data.tar.gz: e44e07b46ab356a82f54ced938557afa1ac6c9c8
+SHA512:
+  metadata.gz: d8ba6d4b830ded0cd7a9b8cc49da49abba3cd51f2a1410d58bde58b3b5f8b4daf39d5929891585d6b07d077c664a779c9e74fa289a829b1dc7afca530d639ef2
+  data.tar.gz: d8369009288c302bba97b9769e23910f63698873cc1b5f7a125663c49656794b9d0b9a7fcb09a925daf7b37ef679390ec8c4a5d28b1831405c53f45ab2ab4459

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/CODE_OF_CONDUCT.md

@@ -0,0 +1,15 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of overtly sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces where an individual explicitly associates their presence with the project; non-project related material on accounts explicitly marked as personal should not be considered to be so associated.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Opal Code of Conduct](https://github.com/opal/opal/blob/master/CODE_OF_CONDUCT.md), which in turn is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jared White
+
+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 @@
+# Polished: Knockout
+
+An [Opal (Ruby-to-JS)](http://opalrb.org) library for creating view models that use Knockout.js for dynamic HTML updates and event handling.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'polished-knockout'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install polished-knockout
+
+## Getting Started
+
+Read the [Getting Started](http://polished-rb.github.io/knockout-rb/getting-started/) tutorial to see how easy it is to build view models and load in JSON data. Sneak peak:
+
+```ruby
+class UserView < Knockout::ViewModel
+  bind_accessor   :first_name, :last_name, :age, :user_types
+  bind_collection :favorite_foods, class_name: 'FavoriteFoodView'
+end
+```
+
+For more in-depth documentation, visit the [Documentation](http://polished-rb.github.io/knockout-rb/docs/) page.
+
+## Contributing
+
+1. Fork it ( http://github.com/polished-rb/knockout/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 new Pull Request
+
+## Testing
+
+Simply run `rackup` at your command line when you're in the project folder. It will load a webserver at port 9292. Then just go to your browser and access `http://localhost:9292`. You should get the full rspec suite runner output. (And hopefully, everything's green!)

data/Rakefile

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

data/config.ru

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler.require
+
+require 'opal-rspec'
+Opal.append_path File.expand_path('../spec', __FILE__)
+
+require 'opal/jquery'
+
+run Opal::Server.new { |s|
+  s.main = 'opal/rspec/sprockets_runner'
+  s.append_path 'spec'
+  s.debug = false
+  s.index_path = 'spec/knockout/index.html.erb'
+}

data/lib/polished/knockout/helpers/knockout_helpers.rb

@@ -0,0 +1,14 @@
+module PolishedKnockout
+  module KnockoutHelpers
+    def knockout(partial=nil, subview:nil, bind_as:nil)
+      if partial
+        render(partial: 'knockout/' + partial.to_s)
+      elsif subview
+        subview_with = bind_as || subview.split('/').last
+        content_tag(:div, 'data-bind' => "with: #{subview_with}") do
+          render(partial: 'knockout/' + subview.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/polished/knockout/railtie.rb

@@ -0,0 +1,8 @@
+require 'polished/knockout/helpers/knockout_helpers'
+module PolishedKnockout
+  class Railtie < Rails::Railtie
+    initializer "polished_knockout.knockout_helpers" do
+      ActiveSupport.on_load( :action_view ){ include PolishedKnockout::KnockoutHelpers }
+    end
+  end
+end

data/lib/polished/knockout/version.rb

@@ -0,0 +1,5 @@
+module Polished
+  module Knockout
+    VERSION = "0.1.0"
+  end
+end

data/lib/polished/knockout/view_model.rb

@@ -0,0 +1,346 @@
+# Knockout::ViewModel provides a simple Opal-based Ruby wrapper around
+# Knockout.js, a popular front-end data-binding and events library.
+#
+# Run one or more of these class methods in a Knockout::ViewModel
+# subclass, aka
+#
+# bind_var    :somevar, :anothervar
+# bind_event  :clickme
+#
+# and then wrappers will be created for the JS model that is passed to
+# Knockout
+#
+# You can either do attr_accessor :somevar, :anothervar or write custom
+# methods in your class, or you can use the shortcut bind_accessor to set
+# up bind_var and attr_accessor at once.
+#
+# You'll need to use bind_id on a top-level view to target an element in your
+# DOM with data-bind-id:
+#
+# bind_id      :some-id
+#
+# Example HTML:
+# <div data-bind-id="some-id">
+#  <span data-bind="text: somevar"> </span>, <span data-bind="html: anothervar"> </span>
+# </div>
+#
+# Methods in your class are passed a jQuery event object, for example:
+#
+# <a href="#" data-bind="click: clickme">Click me!</a>
+#
+# def clickme(event)
+#   puts event.page_x
+# end
+#
+# TODO: remove dependency on jQuery events, so for example opal-browser events
+# could also be used
+#
+# -----
+#
+# Subview docs forthcoming...
+#
+
+module Knockout
+  class ViewModel
+
+    def self.bind_setup
+      if @bind_defs.nil?
+        @bind_defs = {
+          :vars => [],
+          :subviews => [],
+          :collections => [],
+          :events => [],
+          :methods => []
+        }
+        attr_accessor :parent_view
+      end
+    end
+
+    def self.bind_id(bind_id)
+      bind_setup
+      @bind_defs[:id] = bind_id
+    end
+    def self.bind_var(*arr)
+      bind_setup
+      @bind_defs[:vars] += arr
+    end
+    def self.bind_accessor(*arr)
+      bind_setup
+      @bind_defs[:vars] += arr
+      attr_accessor(*arr)
+    end
+    def self.bind_collection(name, options=nil)
+      bind_setup
+      @bind_defs[:collections] << {
+        varname: name,
+        class_name: options.is_a?(Hash) ? options[:class_name] : nil
+      }
+      attr_accessor(name)
+    end
+    def self.bind_event(*arr)
+      bind_setup
+      @bind_defs[:events] += arr
+    end
+    def self.bind_method(*arr)
+      bind_setup
+      @bind_defs[:methods] += arr
+    end
+  
+    def self.bind_defs
+      @bind_defs
+    end
+
+    def initialize
+      begin
+        @bound_model = `{}`
+        self.class.bind_defs()[:vars].each do |var_label|
+          if self.send(var_label).is_a?(KnockoutArray)
+            ko_arr_observable = self.send(var_label).to_n
+            `self.bound_model[var_label] = ko_arr_observable`
+# At some point, figure out how to make it so
+# foomodel.array = ['abc', 123]
+# actually just clears and adds back in stuff via the magic
+# KnockoutArray stuff
+#
+#           define_singleton_method("#{var_label}=") do |val|
+#             result = super val
+#             attribute_did_change(attribute)
+#             result
+#           end
+          else
+            `self.bound_model[var_label] = ko.observable(null)`
+            `var skipit = '_skip_observable_' + var_label`
+            `self.bound_model[var_label].subscribe(function(newValue) {`
+              `if (typeof self[skipit] == 'undefined' || self[skipit] != true) {
+                self[skipit] = true`
+                self.send(var_label + "=", `newValue`)
+                `self[skipit] = false`
+              `}`
+            `});`
+            self.add_observer(var_label) do |new_val|
+              if new_val.is_a?(Array) or new_val.is_a?(Hash) or new_val.is_a?(ViewModel)
+                new_val = new_val.to_n  # to_n converts an Opal-based object to a "native" JS object
+              end
+              `if (typeof self[skipit] == 'undefined' || self[skipit] != true) { `
+                `self[skipit] = true`
+                `self.bound_model[var_label](new_val)`
+              `}`
+              `self[skipit] = false`
+            end
+          end
+        end if self.class.bind_defs()[:vars]
+        
+        self.class.bind_defs()[:collections].each do |collection|
+          var_label = collection[:varname]
+          ko_arr = KnockoutArray.new
+          ko_arr.set_collection_class(collection[:class_name], self)
+          self.send(var_label + '=', ko_arr)
+          ko_arr_observable = self.send(var_label).to_n
+          `self.bound_model[var_label] = ko_arr_observable`
+        end if self.class.bind_defs()[:collections]   
+
+        self.class.bind_defs()[:events].each do |method_label|
+          `self.bound_model[method_label] = function(data, event) { return self['$handle_bind_event'](method_label, event) }`
+        end if self.class.bind_defs()[:events]
+    
+        self.class.bind_defs()[:methods].each do |method_label|
+          `self.bound_model[method_label] = function(data) { return self['$handle_bind_method'](method_label, data) }`
+        end if self.class.bind_defs()[:methods]
+    
+        if self.class.bind_defs()[:id]
+          bind_id = self.class.bind_defs()[:id]
+          bind_el = `$('[data-bind-id=' + bind_id + ']')`
+          `ko.applyBindings(self.bound_model, bind_el.get(0))`
+          `bind_el.addClass('ko-bound')`
+        end
+      rescue Exception => e
+        Element.find('body').add_class('ko-debug')
+        raise e
+      end
+    end
+    
+    def self.new_via_collection(hash_obj, parent=nil)
+      new_object = self.new
+      new_object.parent_view = parent if parent
+      hash_obj.each do |k,v|
+        if v.is_a?(Array) and new_object.send(k).is_a?(KnockoutArray)
+          ko_arr = new_object.send(k)
+          ko_arr.clear
+          ko_arr.concat(v)
+        else
+          new_object.send(k + "=", v)
+        end
+      end
+      new_object
+    end
+    
+    def self.new_with_parent(parent, *arr)
+      new_object = self.new(*arr)
+      new_object.parent_view = parent
+      new_object
+    end
+    
+    def bound_model
+      @bound_model
+    end
+  
+    def handle_bind_event(method_label, event)
+      wrapped_event = Event.new(event)
+      self.send(method_label, wrapped_event)
+    end
+    
+    def handle_bind_method(method_label, data)
+      self.send(method_label, data)
+    end
+  
+    ### Override the standard to_n feature by passing along the Knockout model obj instead
+    def to_n
+      bound_model
+    end
+    
+    def to_json
+      `ko.toJSON(#{@bound_model})`
+    end
+    
+    def serialize_js_data
+      `ko.toJS(#{@bound_model})`
+    end
+  
+    ### The following Ruby observer code was borrowed from Vienna::Observable
+    ### https://github.com/opal/vienna
+    def add_observer(attribute, &handler)
+      unless observers = @attr_observers
+        observers = @attr_observers = {}
+      end
+
+      unless handlers = observers[attribute]
+        handlers = observers[attribute] = []
+        replace_writer_for(attribute)
+      end
+
+      handlers << handler
+    end
+
+    def remove_observer(attribute, handler)
+      return unless @attr_observers
+
+      if handlers = @attr_observers[attribute]
+        handlers.delete handler
+      end
+    end
+
+    # Triggers observers for the given attribute. You may call this directly if
+    # needed, but it is generally called automatically for you inside a
+    # replaced setter method.
+    def attribute_did_change(attribute)
+      return unless @attr_observers
+
+      if handlers = @attr_observers[attribute]
+        new_val = __send__(attribute) if respond_to?(attribute)
+        handlers.each { |h| h.call new_val }
+      end
+    end
+
+    # private?
+    def replace_writer_for(attribute)
+      if respond_to? "#{attribute}="
+        define_singleton_method("#{attribute}=") do |val|
+          result = super val
+          attribute_did_change(attribute)
+          result
+        end
+      end
+    end
+  end 
+end
+
+# This class is used internally and you shouldn't need to initialize it
+# yourself or worry too much whether an array is a standard array or a
+# KnockoutArray
+#
+class KnockoutArray < Array
+  # NOTE: this method has to be run right after a KnockoutArray is first
+  # initialized
+  def to_n
+    array_value = super
+    
+    @ko_observable = `ko.observableArray(array_value)`
+    
+    @ko_observable
+  end
+  
+  def to_json
+    `ko.toJSON(#{@ko_observable})`
+  end
+  
+  def serialize_js_data
+    `ko.toJS(#{@ko_observable})`
+  end
+  
+  def set_collection_class(class_name, collection_parent)
+    @collection_class_name = class_name if class_name
+    @collection_parent = collection_parent
+  end
+  
+  def collection_check(obj)
+    if @collection_class_name and obj.is_a?(Hash)
+      Kernel.const_get(@collection_class_name).new_via_collection(obj, @collection_parent)
+    else
+      obj
+    end
+  end
+  
+  def concat(other)
+    if Array === other
+      other = other.to_a
+    else
+      other = Opal.coerce_to(other, Array, :to_ary).to_a
+    end
+
+    other.each do |item|
+      self.send('<<', item)
+    end
+
+    self
+  end
+  
+  def <<(obj)
+    obj = collection_check(obj)
+    
+    ret = super(obj)
+    
+    `self.ko_observable.push(obj.$to_n())`
+    
+    ret
+  end
+  
+  def delete_at(index)
+    ret = super(index)
+    
+    unless ret == nil
+      `self.ko_observable.splice(index, 1)`
+    end
+    
+    ret
+  end
+  
+  def delete(obj)
+    obj_index = index(obj)
+    ret = nil
+    
+    unless obj_index == nil
+      ret = super(obj)
+      `self.ko_observable.splice(obj_index, 1)`
+    end
+    
+    ret
+  end
+  
+  def clear()
+    ret = super
+    
+    `self.ko_observable.removeAll()`
+    
+    ret
+  end
+end

data/lib/polished/knockout.rb

@@ -0,0 +1,10 @@
+if RUBY_ENGINE == 'opal'
+  require 'polished/knockout/view_model'
+else
+  require 'opal'
+  require 'polished/knockout/version'
+
+  Opal.append_path File.expand_path('../..', __FILE__).untaint
+  
+  require 'polished/knockout/railtie' if defined?(Rails::Railtie)
+end

data/lib/polished-knockout.rb

@@ -0,0 +1 @@
+require 'polished/knockout'

data/polished-knockout.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'polished/knockout/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "polished-knockout"
+  spec.version       = Polished::Knockout::VERSION
+  spec.authors       = ["Jared White"]
+  spec.email         = ["jared@jaredwhite.com"]
+  spec.description   = %q{An Opal library for creating view models that use Knockout.js for dynamic HTML updates and event handling}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/polished-rb/knockout-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency 'opal', '~> 0.8'
+  spec.add_dependency 'opal-jquery', '~> 0.4'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'opal-rspec', '~> 0.4'
+end

data/spec/fixtures/users.json

@@ -0,0 +1,34 @@
+[
+	{
+		"first_name": "Jared",
+		"last_name": "White",
+		"age": 33,
+		"user_types": ["Male", "Human"],
+		"favorite_foods": [
+			{
+				"name": "Burrito",
+				"origin": "Mexico"
+			},
+			{
+				"name": "Pizza",
+				"origin": "Italy"
+			}
+		]
+	},
+	{
+		"first_name": "Jasmine",
+		"last_name": "Kitty",
+		"age": 6,
+		"user_types": ["Female", "Cat"],
+		"favorite_foods": [
+			{
+				"name": "Fish",
+				"origin": "Ocean"
+			},
+			{
+				"name": "Kibble",
+				"origin": "Pet Store"
+			}
+		]
+	}
+]

data/spec/knockout/index.html.erb

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Opal Knockout - RSpec Runner</title>  
+  <script src="https://code.jquery.com/jquery-1.8.3.min.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/knockout/3.4.0/knockout-min.js"></script>
+  <%= javascript_include_tag @server.main %>
+</head>
+<body>
+</body>
+</html>

data/spec/server_roundtrip_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+#### ViewModel Classes ####
+class UsersView < Knockout::ViewModel
+  bind_id         "test-users"
+  bind_collection :users, class_name: 'UserView'
+end
+
+class UserView < Knockout::ViewModel
+  bind_accessor   :first_name, :last_name, :age, :user_types
+  bind_collection :favorite_foods, class_name: 'FavoriteFoodView'
+end
+
+class FavoriteFoodView < Knockout::ViewModel
+  bind_accessor   :name
+  bind_var        :origin
+  
+  def origin=(val)
+    @origin = val
+  end
+  def origin
+    @origin ? @origin.upcase : ""
+  end
+end
+
+#### Test Routines ####
+describe 'bindings using server data' do
+  it 'should have HTTP get support' do
+    HTTP.methods.include?(:get)
+  end
+
+  it 'should save an object graph' do
+    uv = UserView.new_via_collection(first_name: 'Dick', last_name: 'Tracy', age: 25, user_types: ["Male", "Human"])
+    
+    # Get the JSON string from the object
+    test_json = uv.to_json
+    
+    expect(test_json).to include('{"first_name":"Dick"')
+    expect(test_json).to include('"user_types":["Male","Human"]')
+    
+      # JSON postback to server would go here :)
+
+      
+    # also make sure real JS data objects work too
+    test_js_graph = uv.serialize_js_data
+    
+    expect(`test_js_graph.last_name`).to eq('Tracy')
+  end
+
+  async 'should bind a view with view collection from JSON' do
+    collection_html = '<div id="bind-userstest" data-bind-id="test-users" style="display:none"><ul data-bind="foreach: users"><li><span data-bind="text: first_name">_</span> loves <span class="favfoods" data-bind="foreach: favorite_foods"><span data-bind="text: name">_</span> from <span data-bind="text: origin">_</span></span></li></ul></div>'
+    Element.find('body') << collection_html
+    
+    users_view = UsersView.new
+    
+    req_url = "/spec/fixtures/users.json"
+    HTTP.get(req_url).then do |response|
+      run_async do
+        users_view.users.concat(response.json)
+        expect(Element.find('#bind-userstest > ul > li:eq(0) > span:eq(0)').text).to eq('Jared')
+        expect(Element.find('#bind-userstest > ul > li:eq(1) > span:eq(0)').text).to eq('Jasmine')
+
+        expect(users_view.users[0].age).to eq(33)
+        
+        expect(users_view.users[1].user_types[1]).to eq('Cat')
+        
+        expect(users_view.users[0].favorite_foods[0].origin).to eq('MEXICO')
+        
+        expect(Element.find('#bind-userstest > ul > li:eq(0) span.favfoods > span:eq(2)').text).to eq('Pizza')
+        
+        users_view.users[0].favorite_foods[1].name = "Lasagna"
+        
+        expect(Element.find('#bind-userstest > ul > li:eq(0) span.favfoods > span:eq(2)').text).to eq('Lasagna')
+      end
+
+    end
+        
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'opal/jquery'
+require 'polished/knockout'

data/spec/view_model_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+#### ViewModel Classes ####
+class TestBindings < Knockout::ViewModel
+  attr_accessor :text_var
+
+  bind_id       "test-bindings"
+  bind_var      :text_var
+  bind_accessor :html_var
+
+  def initialize
+    super
+    self.text_var = "Var 123"
+  end
+end
+
+class TestSubviewBindings < Knockout::ViewModel
+  bind_id         "test-subview-bindings"
+  bind_accessor   :somesubview, :somesubview2
+
+  def initialize
+    super
+    
+    self.somesubview = TestSubView.new_with_parent(self, 100)
+    self.somesubview2 = TestSubView.new_with_parent(self, 200)
+  end
+end
+
+class TestSubView < Knockout::ViewModel
+  bind_accessor   :somevar
+    
+  def initialize(additional_number)
+    super
+        
+    self.somevar = 12345 + additional_number
+  end
+  
+  # multiply the incoming value by 100 and make sure that's reflected in the HTML output
+  def somevar=(val)
+    @somevar = val * 100
+  end
+end
+
+class TestCollection < Knockout::ViewModel
+  bind_id "test-collection"
+  bind_collection :items, class_name: 'TestCollectionItem'
+  
+  def initialize(data)
+    super
+    self.items.concat(data)
+  end
+end
+
+class TestCollectionItem < Knockout::ViewModel
+  bind_accessor   :title
+end
+
+#### Test Routines ####
+describe 'knockout bindings' do
+  before(:all) do
+    @view_html = '<div id="bindtest1" data-bind-id="test-bindings" style="display:none"><span class="text-var" data-bind="text: text_var">_</span><span class="html-var" data-bind="html: html_var"></span></div>'
+    
+    Element.find('body') << @view_html
+    @view_model = TestBindings.new
+  end
+  
+  it 'should bind a string var' do
+    var_element = Element.find('#bindtest1 > span.text-var')
+    expect(var_element.text).to eq('Var 123')
+    @view_model.text_var = "Var 456"
+    expect(var_element.text).to eq('Var 456')
+  end
+  
+  it 'should bind an HTML var' do
+    var_element = Element.find('#bindtest1 > span.html-var')
+    @view_model.html_var = "<strong><em>This is very strong!</em></strong>"
+    expect(var_element.find('strong > em').text).to eq('This is very strong!')
+  end
+  
+  it 'should bind a subview and support data manipulation on setters' do
+    subview_html = '<div id="bindtest2" data-bind-id="test-subview-bindings" style="display:none"><div data-bind="with: somesubview"><span class="text-var" data-bind="text: somevar">_</span></div><div data-bind="with: somesubview2"><span class="text-var" data-bind="text: somevar">_</span></div></div>'
+    Element.find('body') << subview_html
+    view_model = TestSubviewBindings.new
+    expect(Element.find('#bindtest2 > div:eq(0) > span.text-var').text).to eq('1244500')
+    view_model.somesubview.somevar = 67890
+    expect(Element.find('#bindtest2 > div:eq(0) > span.text-var').text).to eq('6789000')
+    
+    # at one point more than one subview was buggy. make sure this is working!!!
+    expect(Element.find('#bindtest2 > div:eq(1) > span.text-var').text).to eq('1254500')
+  end
+end
+
+describe 'bindings with view collections' do
+  it 'should bind a view with view collection objects' do
+    collection_html = '<div id="bindcoltest" data-bind-id="test-collection" style="display:none"><ul data-bind="foreach: items"><li><span data-bind="text: title">_</span></li></ul></div>'
+    Element.find('body') << collection_html
+    
+    load_array = [{title: 'Name 1'}, {title: 'Name 2'}]
+    
+    view_model = TestCollection.new(load_array)
+    
+    expect(Element.find('#bindcoltest > ul > li:eq(0) > span').text).to eq('Name 1')
+    expect(Element.find('#bindcoltest > ul > li:eq(1) > span').text).to eq('Name 2')
+    
+    view_model.items[0].title = "Name 1.0"
+    
+    expect(Element.find('#bindcoltest > ul > li:eq(0) > span').text).to eq('Name 1.0')
+    
+    view_model.items << {title: "Name 3"}
+    
+    expect(Element.find('#bindcoltest > ul > li:eq(2) > span').text).to eq('Name 3')
+    
+    expect(view_model.items[0].parent_view).to eq(view_model)
+    
+    view_model.items << TestCollectionItem.new.tap{|item| item.parent_view = view_model; item.title = "Name 4" }
+    
+    expect(Element.find('#bindcoltest > ul > li:eq(3) > span').text).to eq('Name 4')    
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: polished-knockout
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jared White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: opal-jquery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: An Opal library for creating view models that use Knockout.js for dynamic
+  HTML updates and event handling
+email:
+- jared@jaredwhite.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config.ru
+- lib/polished-knockout.rb
+- lib/polished/knockout.rb
+- lib/polished/knockout/helpers/knockout_helpers.rb
+- lib/polished/knockout/railtie.rb
+- lib/polished/knockout/version.rb
+- lib/polished/knockout/view_model.rb
+- polished-knockout.gemspec
+- spec/fixtures/users.json
+- spec/knockout/index.html.erb
+- spec/server_roundtrip_spec.rb
+- spec/spec_helper.rb
+- spec/view_model_spec.rb
+homepage: https://github.com/polished-rb/knockout-rb
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: An Opal library for creating view models that use Knockout.js for dynamic
+  HTML updates and event handling
+test_files:
+- spec/fixtures/users.json
+- spec/knockout/index.html.erb
+- spec/server_roundtrip_spec.rb
+- spec/spec_helper.rb
+- spec/view_model_spec.rb