hyper-operation 0.5.0

data/examples/five-letter-word-game/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

data/examples/five-letter-word-game/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/examples/five-letter-word-game/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/examples/five-letter-word-game/app/assets/javascripts/application.js

@@ -0,0 +1,3 @@
+//= require jquery
+//= require jquery_ujs
+//= require hyperloop-loader

data/examples/five-letter-word-game/app/assets/javascripts/cable.js

@@ -0,0 +1,13 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the rails generate channel command.
+//
+//= require action_cable
+//= require_self
+//= require_tree ./channels
+
+(function() {
+  this.App || (this.App = {});
+
+  App.cable = ActionCable.createConsumer();
+
+}).call(this);

data/examples/five-letter-word-game/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/examples/five-letter-word-game/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/examples/five-letter-word-game/app/channels/application_cable/connection.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/examples/five-letter-word-game/app/controllers/application_controller.rb

@@ -0,0 +1,14 @@
+::User # force User Model to load so we can get the policies up!
+# Note is important to fully qualify the name otherwise rails gets
+# confused when autoloading, and you will get an error when files changed
+# during development. see http://stackoverflow.com/questions/17561697/argumenterror-a-copy-of-applicationcontroller-has-been-removed-from-the-module/23008837#23008837
+
+class ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+
+  def acting_user
+    session.delete 'hyperloop-dummy-init' unless session.id
+    ::User.find(session.id)
+  end
+
+end

data/examples/five-letter-word-game/app/controllers/home_controller.rb

@@ -0,0 +1,5 @@
+class HomeController < ApplicationController
+  def app
+    render_component "::App"
+  end
+end

data/examples/five-letter-word-game/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/examples/five-letter-word-game/app/hyperloop/components/app.rb

@@ -0,0 +1,65 @@
+require 'stores/store'
+class App < React::Component::Base
+
+  render(DIV) do
+    puts "rendering: game_state = #{Store.game_state}"
+    puts "their_id: #{Store.state.their_id}, my_id: #{Store.my_id} words: #{Store.state.word}"
+    DIV { Store.message } if Store.message
+    send Store.game_state # for each game_state we have a method below...
+    Guesses() unless Store.my_guesses.empty?
+  end
+
+  def initializing
+    SPAN { '...' }
+  end
+
+  def picking_word
+    InputWord label: 'pick a five letter word', button: 'play', operation: Ops::ReadyToPlay
+  end
+
+  def waiting_for_other_player
+    SPAN { "Your word is: #{Store.my_word}. Waiting for the other player to pick their word..." }
+    BUTTON { 'Change Your Word' }.on(:click) { Ops::ChangeWord() }
+  end
+
+  def waiting_for_your_guess
+    InputWord label: 'guess a word', button: 'guess', operation: Ops::Guess
+  end
+
+  def waiting_for_their_guess
+    SPAN { 'waiting for the other player to guess...' }
+  end
+
+  def waiting_for_a_clue_from_them
+    SPAN { 'waiting for the other player to give you the number correct...' }
+  end
+
+  def waiting_for_a_clue_from_you
+    SPAN { "Your word is '#{Store.my_word}'." }
+    SELECT do
+      OPTION(selected: true,  disabled: true) { "How many correct in '#{Store.current_guess}'?" }
+      (0..5).each { |count| OPTION(value: count) { count.to_s } }
+      OPTION(value: :win) { "#{Store.current_guess} is correct!"}
+    end.on(:change) do |e|
+      if e.target.value == :win
+        Ops::YouWin()
+      else
+        Ops::Clue their_word: Store.current_guess, my_word: Store.my_word, correct: e.target.value
+      end
+    end
+  end
+
+  def you_win
+    DIV { "YOU WIN :-)" }
+    play_again
+  end
+
+  def they_win
+    DIV { "they won :-("}
+    play_again
+  end
+
+  def play_again
+    BUTTON { 'Play Again!' }.on(:click) { Ops::PlayAgain() }
+  end
+end

data/examples/five-letter-word-game/app/hyperloop/components/guesses.rb

@@ -0,0 +1,8 @@
+class Guesses < React::Component::Base
+  render(DIV) do
+    OL do
+      Store.my_guesses.each { |guess, no_correct| LI { "#{no_correct} in '#{guess}'" } }
+    end
+    BUTTON { 'quit' }.on(:click) { Ops::YouWin message: 'I quit' } unless Store.game_over?
+  end
+end

data/examples/five-letter-word-game/app/hyperloop/components/input_word.rb

@@ -0,0 +1,13 @@
+class InputWord < React::Component::Base
+  param :label
+  param :button
+  param :operation
+  render(DIV) do
+    LABEL { params.label }
+    INPUT(class: :word)
+    BUTTON { params.button }.on(:click) do
+      params.operation.run(word: Element[dom_node].find('.word').value)
+      .fail { |e| alert e.message }
+    end
+  end
+end

data/examples/five-letter-word-game/app/hyperloop/models/user.rb

@@ -0,0 +1,27 @@
+# dummy user model... just creates an object that responds to #id and
+# is equal to all other instances that have the the same id
+class User
+  def initialize(id)
+    @id = id
+  end
+
+  def ==(other)
+    other && id == other.id
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def self.find(id)
+    new(id) if id
+  end
+
+  def hash
+    id.hash
+  end
+
+  def id
+    @id.to_s
+  end
+end

data/examples/five-letter-word-game/app/hyperloop/operations/ops.rb

@@ -0,0 +1,115 @@
+module Ops
+  class Base < Hyperloop::ServerOp
+    # base class for all the other server side operations
+    # All operations take the acting_user and add outbound
+    # sender and other_player params which are just the ids.
+
+    param :acting_user
+    outbound :sender
+    outbound :other_player
+
+    # partners holds a hash of partner pairs i.e. x => y, y => x
+    # if z is waiting for a partner the hash holds z => nil
+
+    def self.partners
+      @partners ||= {}
+    end
+
+    # find the waiting player
+
+    def waiting_player
+      Base.partners.key(nil)
+    end
+
+    # for a given acting user find the partner
+
+    def other_player
+      Base.partners[params.acting_user]
+    end
+
+    # either attach the acting_user to the waiting player
+    # of if there is no waiting player, make acting_user the waiting player
+
+    def partner_up
+      if waiting_player
+        params.other_player = waiting_player.id
+        Base.partners[params.acting_user] = waiting_player
+        Base.partners[waiting_player] = params.acting_user
+      elsif !Base.partners.key?(params.acting_user)
+        Base.partners[params.acting_user] = nil
+      end
+    end
+
+    # unhook partners at game end
+
+    def unpartner
+      Base.partners.delete other_player
+      Base.partners.delete params.acting_user
+    end
+
+    # check words for validity
+
+    def five_unique_letters
+      return true if params.word.split('').uniq.join =~ /^[a-zA-Z]{5}$/
+      abort "words and guesses must have 5 different letters"
+    end
+
+    # check clue for accuracy
+
+    def check_clue
+      params.true_count =
+        (Set.new(params.their_word.split('')) & params.my_word.split('')).count
+    end
+
+    # grab the ids from the two players
+    step { params.other_player = other_player && other_player.id }
+    step { params.sender = params.acting_user.id }
+    # save the value of other player in case the subclass changes it
+    step { @current_other_player = other_player }
+
+    # dispatch to both players.  The other player may be set or removed during
+    # the operation, so we dispatch to the before and after values
+    dispatch_to { [params.acting_user, other_player, @current_other_player] }
+  end
+
+  class ReadyToPlay < Base
+    param :word, type: String
+    validate :five_unique_letters
+  end
+
+  class ChangeWord < Base
+  end
+
+  class Guess < Base
+    param :word
+    validate :five_unique_letters
+  end
+
+  class Clue < Base
+    param :their_word
+    param :my_word
+    param :correct, type: Integer, min: 0, max: 5
+    outbound :true_count
+    step :check_clue
+  end
+
+  class YouWin < Base
+    param message: nil
+    step :unpartner
+  end
+
+  class Join < Base
+    step :partner_up
+  end
+
+  class ShareState < Base
+    param :guesses
+    param :word
+    param :current_guesser, nils: true
+    param :current_guess,   nils: true
+    param :message
+  end
+
+  class PlayAgain < Hyperloop::Operation
+  end
+end

data/examples/five-letter-word-game/app/hyperloop/stores/store.rb

@@ -0,0 +1,120 @@
+require 'operations/ops'
+class Store < Hyperloop::Store
+  class << self
+
+    def my_guesses
+      state.guesses[my_id]
+    end
+
+    def my_word
+      state.word[my_id]
+    end
+
+    state :current_guess, reader: true
+
+    def message
+      state.message[my_id]
+    end
+
+    def my_id
+      Hyperloop::Application.acting_user_id
+    end
+
+    def game_state
+      if !my_word
+        :picking_word
+      elsif !state.word[state.their_id]
+        :waiting_for_other_player
+      elsif state.winner
+        :"#{state.winner == my_id ? 'you' : 'they'}_win"
+      elsif state.current_guess
+        :"waiting_for_a_clue_from_#{state.current_guesser == my_id ? 'them' : 'you'}"
+      else
+        :"waiting_for_#{state.current_guesser == my_id ? 'your' : 'their'}_guess"
+      end
+    end
+
+    def game_over?
+      game_state =~ /_win$/
+    end
+
+    def setup
+      mutate.guesses Hash.new { |guesses, player| guesses[player] = [] }
+      mutate.winner nil
+      mutate.word Hash.new
+      mutate.current_guesser nil
+      mutate.current_guess nil
+      mutate.their_id nil
+      mutate.message Hash.new
+      Ops::Join.run if Hyperloop.on_client?
+    end
+  end
+
+  receives Ops::Join do |params|
+    puts "receiving Ops::Join(#{params})"
+    if state.their_id && params.sender != my_id
+      Ops::ShareState(
+        guesses: state.guesses,
+        word: state.word,
+        current_guesser: state.current_guesser,
+        current_guess: state.current_guess,
+        message: state.message
+      )
+    else
+      mutate.their_id params.sender != my_id ? params.sender : params.other_player
+      Ops::ReadyToPlay.run(word: state.word[my_id]) if state.word[my_id]
+    end
+  end
+
+  receives Ops::ShareState do |params|
+    puts "receiving Ops::ShareState(#{params})"
+    if params.sender != my_id
+      params.guesses.each { |player, guesses| mutate.guesses[player] = guesses }
+      mutate.word params.word
+      mutate.current_guesser params.current_guesser
+      mutate.current_guess params.current_guess
+      mutate.message params.message
+    end
+  end
+
+  receives Ops::ReadyToPlay do |params|
+    puts "receiving Ops::ReadyToPlay(#{params})"
+    mutate.current_guesser params.sender unless state.current_guesser
+    mutate.word[params.sender] = params.word
+  end
+
+  receives Ops::ChangeWord do |params|
+    puts "receiving Ops::ChangeWord(#{params})"
+    mutate.word[params.sender] = nil
+    mutate.current_guesser nil if params.sender == state.current_guesser
+  end
+
+  receives Ops::Guess do |params|
+    puts "receiving Ops::Guess(#{params})"
+    mutate.current_guess params.word
+    mutate.message({})
+  end
+
+  receives Ops::Clue do |params|
+    puts "receiving Ops::Clue(#{params})"
+    mutate.guesses[params.other_player] << [state.current_guess, params.true_count]
+    if params.true_count == params.correct
+      mutate.current_guesser params.sender
+    else
+      mutate.message[params.sender] =
+        "That was a bogus clue.  There are #{params.true_count} correct in #{current_guess}.  They get a free guess!"
+      mutate.message[params.other_player] =
+        "They tried to give you a bogus clue!  There are #{params.true_count} correct in #{current_guess}.  Have a free turn!"
+    end
+    mutate.current_guess nil
+  end
+
+  receives Ops::YouWin do |params|
+    puts "receiving Ops::YouWin(#{params})"
+    mutate.winner params.other_player
+    mutate.message params.message
+  end
+
+  receives Ops::PlayAgain, :setup
+  receives Hyperloop::Application::Boot, :setup
+end