hokusai-zero 0.1.3 → 0.1.4

data/ui/examples/stock.rb

@@ -5,111 +5,105 @@ require_relative "./stock_decider/option"
 
 # aim for over 24 percent sort by percentage first
 # 3 week = 1 option premium * 100 shares / 12
-module StockDecider
-  # Expecting a data prop in the form of
-  #
-  class StackedBar < Hokusai::Block
-    COLORS = {
-      :week_3 => [157, 221, 117],
-      :week_4 => [117, 157, 221],
-      :week_5 => [221, 180, 117]
-    }
-
-    template <<~EOF
-      [template]
-        virtual
-    EOF
-
-    uses(
-      vblock: Hokusai::Blocks::Vblock,
-      label: Hokusai::Blocks::Label
-    )
-
-    computed! :data
-
-    def symbol
-      data[0]
-    end
+module Demos
+  module StockDecider
+    class StackedBar < Hokusai::Block
+      COLORS = {
+        :week_3 => [157, 221, 117],
+        :week_4 => [117, 157, 221],
+        :week_5 => [221, 180, 117]
+      }
+
+      template <<~EOF
+        [template]
+          virtual
+      EOF
+
+      uses(
+        vblock: Hokusai::Blocks::Vblock,
+        label: Hokusai::Blocks::Label
+      )
+
+      computed! :data
+
+      def symbol
+        data[0]
+      end
 
-    def render(canvas)
-      key, weeks = data
-      theight = canvas.height - 50
-      draw do
-        weeks.reject(&:nil?).sort { |a, b| b <=> a }.each_with_index do |percent, idx|
-          color = COLORS["week_#{idx + 3}".to_sym]
-          height = (theight * percent) / 100
-          y = canvas.y + theight - height
-
-          rect(canvas.x, y , 150, height) do |command|
-            command.color = Hokusai::Color.convert(color)
-            command.outline = Hokusai::Outline.convert("4,4, 0, 0")
-            command.outline_color = Hokusai::Color.convert("0,0,0,110")
+      def render(canvas)
+        key, weeks = data
+        theight = canvas.height - 50
+        draw do
+          weeks.reject(&:nil?).sort { |a, b| b <=> a }.each_with_index do |percent, idx|
+            color = COLORS["week_#{idx + 3}".to_sym]
+            height = (theight * percent) / 100
+            y = canvas.y + theight - height
+
+            rect(canvas.x, y , 150, height) do |command|
+              command.color = Hokusai::Color.convert(color)
+              command.outline = Hokusai::Outline.convert("4,4, 0, 0")
+              command.outline_color = Hokusai::Color.convert("0,0,0,110")
+            end
+
+            text("Week #{idx + 3} (#{percent.round(2)})", canvas.x + 2, y + 10) do |command|
+              command.size = 12
+            end
           end
 
-          text("Week #{idx + 3} (#{percent.round(2)})", canvas.x + 2, y + 10) do |command|
-            command.size = 12
+          text(symbol, canvas.x + 12, theight + 5) do |command|
+            command.size = 25
+            command.color = Hokusai::Color.new(233,233,233,255)
           end
         end
 
-        text(symbol, canvas.x + 12, theight + 5) do |command|
-          command.size = 25
-          command.color = Hokusai::Color.new(233,233,233,255)
-        end
+        canvas.x -= 100
+        yield canvas
       end
-
-      canvas.x -= 100
-      yield canvas
     end
-  end
 
-  class App < Hokusai::Block
-    template <<~EOF
-      [template]
-        vblock { background="84,23,77" padding="0,20,0,20"}
-          hblock { padding="0,20,0,20"}
-            [for="data in attractive_options"]
-              stackedbar { :key="key(index)" :data="data" }
-    EOF
-
-    uses(
-      vblock: Hokusai::Blocks::Vblock,
-      hblock: Hokusai::Blocks::Hblock,
-      stackedbar: StackedBar
-    )
-
-    def attractive_options
-      @options.to_a
-    end
+    class App < Hokusai::Block
+      template <<~EOF
+        [template]
+          vblock { background="84,23,77" padding="0,20,0,20"}
+            hblock { padding="0,20,0,20"}
+              [for="data in attractive_options"]
+                stackedbar { :key="key(index)" :data="data" }
+      EOF
+
+      uses(
+        vblock: Hokusai::Blocks::Vblock,
+        hblock: Hokusai::Blocks::Hblock,
+        stackedbar: StackedBar
+      )
+
+      def attractive_options
+        @options.to_a
+      end
 
-    def key(index)
-      "Key_#{index}"
-    end
+      def key(index)
+        "Key_#{index}"
+      end
 
-    def on_mounted
-      puts ["mounted"]
-      add_ticker("TSLA")
-      add_ticker("OXY")
-      add_ticker("DG")
-    end
+      def on_mounted
+        puts ["mounted"]
+        add_ticker("TSLA")
+        add_ticker("OXY")
+        add_ticker("DG")
+      end
 
-    def add_ticker(sym)
-      ticker_opts = Option.from_ticker(sym)
-      w3 = ticker_opts.select { |a| a.attractive?(3) }.sort_by { |a| a.percent(3) }.last
-      w4 = ticker_opts.select { |a| a.attractive?(4) }.sort_by { |a| a.percent(4) }.last
-      w5 = ticker_opts.select { |a| a.attractive?(5) }.sort_by { |a| a.percent(5) }.last
-      @options[sym] = [w3&.percent(3), w4&.percent(4), w5&.percent(5)]
-      puts @options[sym]
-    end
+      def add_ticker(sym)
+        ticker_opts = Option.from_ticker(sym)
+        w3 = ticker_opts.select { |a| a.attractive?(3) }.sort_by { |a| a.percent(3) }.last
+        w4 = ticker_opts.select { |a| a.attractive?(4) }.sort_by { |a| a.percent(4) }.last
+        w5 = ticker_opts.select { |a| a.attractive?(5) }.sort_by { |a| a.percent(5) }.last
+        @options[sym] = [w3&.percent(3), w4&.percent(4), w5&.percent(5)]
+        puts @options[sym]
+      end
 
-    def initialize(**args)
-      @options = {}
-      super
+      def initialize(**args)
+        @options = {}
+        super
+      end
     end
   end
 end
-# #
-# Hokusai::Backends::SDLBackend.run(StockDecider::App) do |config|
-#   config.width = 500
-#   config.height = 500
-#   config.title = "Loop application"
-# end

data/ui/examples/stock_decider/option.rb

@@ -2,7 +2,7 @@ require 'json'
 require 'date'
 require "rest-client"
 
-module StockDecider
+module Demos::StockDecider
   class Option
     URL = "https://cdn.cboe.com/api/global/delayed_quotes/options"
     def self.from_ticker(sym)

data/ui/examples/tic_tac_toe.rb

@@ -2,238 +2,240 @@ require_relative "../src/hokusai"
 require_relative "../src/hokusai/backends/raylib"
 require_relative "../src/hokusai/backends/sdl2"
 
-module TicTacToe
-  module Player
-    X = 0
-    O = 1
-    None = 2
-  end
-
-  class Square < Hokusai::Block
-    style <<-EOF
-    [style]
-    squareStyle {
-      outline: 3.0;
-      outline_color: rgb(233,233,233);
-    }
-    EOF
-
-    template <<-EOF
-    [template]
-      vblock { 
-        @click="emit_position"
-        @hover="set_hover"
-        @mouseout="set_mouseout"
-        :background="compute_background" 
-        ...squareStyle
+module Demos
+  module TicTacToe
+    module Player
+      X = 0
+      O = 1
+      None = 2
+    end
+
+    class Square < Hokusai::Block
+      style <<-EOF
+      [style]
+      squareStyle {
+        outline: 3.0;
+        outline_color: rgb(233,233,233);
       }
-        label { height="13" :content="read_position" }
-        [if="has_player"]
-          image { :source="square_image" }
-    EOF
-
-    computed! :player
-    computed! :position
-
-    uses(
-      vblock: Hokusai::Blocks::Vblock,
-      image: Hokusai::Blocks::Image,
-      label: Hokusai::Blocks::Label
-    )
-
-    def compute_background
-      case player
-      when Player::X
-        [52,168,77]
-      when Player::O
-        [219,176,57]
-      when Player::None
-        @hover ? [55, 110, 155] : [47,98,140]
+      EOF
+
+      template <<-EOF
+      [template]
+        vblock { 
+          @click="emit_position"
+          @hover="set_hover"
+          @mouseout="set_mouseout"
+          :background="compute_background" 
+          ...squareStyle
+        }
+          label { height="13" :content="read_position" }
+          [if="has_player"]
+            image { :source="square_image" }
+      EOF
+
+      computed! :player
+      computed! :position
+
+      uses(
+        vblock: Hokusai::Blocks::Vblock,
+        image: Hokusai::Blocks::Image,
+        label: Hokusai::Blocks::Label
+      )
+
+      def compute_background
+        case player
+        when Player::X
+          [52,168,77]
+        when Player::O
+          [219,176,57]
+        when Player::None
+          @hover ? [55, 110, 155] : [47,98,140]
+        end
       end
-    end
 
-    def set_hover(event)
-      @hover = true
-    end
+      def set_hover(event)
+        @hover = true
+      end
 
-    def set_mouseout(event)
-      @hover = false
-    end
+      def set_mouseout(event)
+        @hover = false
+      end
 
-    def read_position
-      position.inspect
-    end
+      def read_position
+        position.inspect
+      end
 
-    def emit_position(click)
-      emit("position", position)
-    end
+      def emit_position(click)
+        emit("position", position)
+      end
 
-    def has_player
-      player != Player::None
-    end
+      def has_player
+        player != Player::None
+      end
 
-    def square_image
-      case player
-      when Player::X
-        return "#{__dir__}/assets/science-troll.png"
-      when Player::O
-        return "#{__dir__}/assets/football-troll.png"
+      def square_image
+        case player
+        when Player::X
+          return "#{__dir__}/assets/science-troll.png"
+        when Player::O
+          return "#{__dir__}/assets/football-troll.png"
+        end
       end
     end
-  end
 
-  class Row < Hokusai::Block
-    template <<-EOF
-    [template]
-      hblock
-        [for="player in row"]
-          square { cursor="pointer" @position="emit_position" :player="player" :key="key(index)" :position="position(index)" }
-    EOF
+    class Row < Hokusai::Block
+      template <<-EOF
+      [template]
+        hblock
+          [for="player in row"]
+            square { cursor="pointer" @position="emit_position" :player="player" :key="key(index)" :position="position(index)" }
+      EOF
 
-    uses(
-      square: Square,
-      hblock: Hokusai::Blocks::Hblock
-    )
+      uses(
+        square: Square,
+        hblock: Hokusai::Blocks::Hblock
+      )
 
-    computed! :row
-    computed! :row_index
+      computed! :row
+      computed! :row_index
 
-    def emit_position(pos)
-      emit("position", pos)
-    end
+      def emit_position(pos)
+        emit("position", pos)
+      end
 
-    def key(index)
-      "player_#{row_index}_#{index}"
-    end
+      def key(index)
+        "player_#{row_index}_#{index}"
+      end
 
-    def position(index)
-      [row_index, index]
-    end
+      def position(index)
+        [row_index, index]
+      end
 
-  end
+    end
 
-  class App < Hokusai::Block
-    template <<-EOF
-    [template]
-      vblock
-        [if="has_winner"]
-          vblock { background="10,10,10,222" }
-            img { :source="winner_image"}
+    class App < Hokusai::Block
+      template <<-EOF
+      [template]
+        vblock
+          [if="has_winner"]
+            vblock { background="10,10,10,222" }
+              img { :source="winner_image"}
+              vblock
+                label { :content="winner_text"  color="255,255,255", size="30"}
+                label { @click="restart" color="222,199,199" size="20" content="restart"}
+          [else]
             vblock
-              label { :content="winner_text"  color="255,255,255", size="30"}
-              label { @click="restart" color="222,199,199" size="20" content="restart"}
-        [else]
-          vblock
-            [for="row in board"]
-              row { @position="update_game" :row="row" :key="key(index)" :row_index="index" }
-    EOF
-
-    uses(
-      row: Row,
-      vblock: Hokusai::Blocks::Vblock,
-      hblock: Hokusai::Blocks::Hblock,
-      label: Hokusai::Blocks::Label,
-      empty: Hokusai::Blocks::Empty,
-      img: Hokusai::Blocks::Image
-    )
-
-    attr_accessor :current_player, :board, :count
-
-    def initialize(**args)
-      @current_player = Player::X
-      @count = 0
-      super
-
-      restart
-    end
+              [for="row in board"]
+                row { @position="update_game" :row="row" :key="key(index)" :row_index="index" }
+      EOF
+
+      uses(
+        row: Row,
+        vblock: Hokusai::Blocks::Vblock,
+        hblock: Hokusai::Blocks::Hblock,
+        label: Hokusai::Blocks::Label,
+        empty: Hokusai::Blocks::Empty,
+        img: Hokusai::Blocks::Image
+      )
+
+      attr_accessor :current_player, :board, :count
+
+      def initialize(**args)
+        @current_player = Player::X
+        @count = 0
+        super
+
+        restart
+      end
 
-    def restart(*args)
-      @board = [
-        [Player::None, Player::None, Player::None],
-        [Player::None, Player::None, Player::None],
-        [Player::None, Player::None, Player::None]
-      ]
-      self.count = 0
-    end
+      def restart(*args)
+        @board = [
+          [Player::None, Player::None, Player::None],
+          [Player::None, Player::None, Player::None],
+          [Player::None, Player::None, Player::None]
+        ]
+        self.count = 0
+      end
 
-    def key(index)
-      "row_#{index}"
-    end
+      def key(index)
+        "row_#{index}"
+      end
 
-    def winner_image
-      case winner
-      when Player::X
-        return "#{__dir__}/assets/science-troll.png"
-      when Player::O
-        return "#{__dir__}/assets/football-troll.png"
-      else
-        return "#{__dir__}/assets/baby_sean.png"
+      def winner_image
+        case winner
+        when Player::X
+          return "#{__dir__}/assets/science-troll.png"
+        when Player::O
+          return "#{__dir__}/assets/football-troll.png"
+        else
+          return "#{__dir__}/assets/baby_sean.png"
+        end
       end
-    end
 
-    def winner_text
-      case winner
-      when Player::X
-        "Player X won!"
-      when Player::O
-        "Player O won!"
-      else
-        "No winner"
+      def winner_text
+        case winner
+        when Player::X
+          "Player X won!"
+        when Player::O
+          "Player O won!"
+        else
+          "No winner"
+        end
       end
-    end
 
-    def has_winner
-      count >= 9 || !check_win.nil?
-    end
+      def has_winner
+        count >= 9 || !check_win.nil?
+      end
 
-    def winner
-      check_win
-    end
+      def winner
+        check_win
+      end
 
-    def update_game(position)
-      row, col = position
+      def update_game(position)
+        row, col = position
 
-      self.count += 1
+        self.count += 1
 
-      case current_player
-      when Player::X
-        board[row][col] = Player::X unless board[row][col] != Player::None
-        self.current_player = Player::O
-      when Player::O
-        board[row][col] = Player::O unless board[row][col] != Player::None
-        self.current_player = Player::X
+        case current_player
+        when Player::X
+          board[row][col] = Player::X unless board[row][col] != Player::None
+          self.current_player = Player::O
+        when Player::O
+          board[row][col] = Player::O unless board[row][col] != Player::None
+          self.current_player = Player::X
+        end
       end
-    end
 
-    def check_win
-      [Player::X, Player::O].each do |player|
-        (0...3).step do |i|
-          if board[i][0] == player && board[i][1] == player && board[i][2] == player
-            return player
-          end
+      def check_win
+        [Player::X, Player::O].each do |player|
+          (0...3).step do |i|
+            if board[i][0] == player && board[i][1] == player && board[i][2] == player
+              return player
+            end
 
-          if board[0][i] == player && board[1][i] == player && board[2][i] == player
-            return player
-          end
+            if board[0][i] == player && board[1][i] == player && board[2][i] == player
+              return player
+            end
 
-          diagonal_left = board[0][0] == player && board[1][1] == player && board[2][2] == player
-          diagonal_right = board[2][0] == player && board[1][1] == player && board[0][2] == player
+            diagonal_left = board[0][0] == player && board[1][1] == player && board[2][2] == player
+            diagonal_right = board[2][0] == player && board[1][1] == player && board[0][2] == player
 
-          if diagonal_left || diagonal_right
-            return player
+            if diagonal_left || diagonal_right
+              return player
+            end
           end
         end
-      end
 
-      nil
-    end
+        nil
+      end
 
-    def render(canvas)
-      if Hokusai.can_render(canvas)
+      def render(canvas)
+        if Hokusai.can_render(canvas)
 
-        emit("width", canvas.width)
+          emit("width", canvas.width)
 
-        yield canvas
+          yield canvas
+        end
       end
     end
   end

data/ui/lib/lib_hokusai.rb

@@ -29,7 +29,6 @@ module LibHokusai
 
   def self.parse_style(template)
     ptr = FFI::MemoryPointer.new :pointer
-    pp template
     code = LibHokusai.hoku_style_from_template(ptr, template)
 
     raise LibHokusai::Error.new("Couldn't parse style template") unless code.zero?