hyper-operation 0.5.12 → 0.99.0

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

@@ -1,24 +0,0 @@
-# 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

@@ -1,6 +0,0 @@
-# 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

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

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

@@ -1,4 +0,0 @@
-//= require jquery
-//= require jquery_ujs
-//= require hyperloop-loader
-Opal.OpalHotReloader.$listen(25222)

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

@@ -1,13 +0,0 @@
-// 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

@@ -1,15 +0,0 @@
-/*
- * 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

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

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

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

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

@@ -1,14 +0,0 @@
-::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

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

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

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

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

@@ -1,65 +0,0 @@
-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 a word...' }
-  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

@@ -1,8 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,27 +0,0 @@
-# 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

@@ -1,115 +0,0 @@
-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.downcase.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.downcase.split('')) & params.my_word.downcase.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

@@ -1,120 +0,0 @@
-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[my_id] = params.message
-  end
-
-  receives Ops::PlayAgain, :setup
-  receives Hyperloop::Application::Boot, :setup
-end