toji 1.6.7 → 2.2.0

data/lib/toji/brew/shubo.rb

@@ -2,11 +2,6 @@ module Toji
   module Brew
     class Shubo < Base
 
-      state_reader :mizukoji
-      state_reader :shikomi
-      state_reader :utase
-      state_reader :wake
-
       def progress(name: nil, dash: :solid, enable_annotations: true)
         Graph::Progress.new(self, name: name, dash: dash, enable_annotations: enable_annotations)
       end

data/lib/toji/brew/state.rb

@@ -1,134 +1,121 @@
-require 'forwardable'
-
 module Toji
   module Brew
-    class State
-      extend Forwardable
+    module State
+      KEYS = [
+        :time,
+        :elapsed_time,
+        :mark,
+        :temps,
+        :preset_temp,
+        :room_temp,
+        :room_psychrometry,
+        :baume,
+        :nihonshudo,
+        :acid,
+        :amino_acid,
+        :alcohol,
+        :warmings,
+        :note,
+      ].freeze
 
-      attr_accessor :elapsed_time
       attr_accessor :time
-      attr_reader :record
-      attr_reader :brew
-
-      def_delegators :@record, :mark
-      def_delegators :@record, :temps
-      def_delegators :@record, :preset_temp
-      def_delegators :@record, :room_temp
-      def_delegators :@record, :room_psychrometry
-      def_delegators :@record, :acid
-      def_delegators :@record, :amino_acid
-      def_delegators :@record, :alcohol
-      def_delegators :@record, :warmings
-      def_delegators :@record, :note
-
-      def initialize(elapsed_time, record, brew)
-        @elapsed_time = elapsed_time
-        @record = record
-        @brew = brew
-      end
+      attr_accessor :elapsed_time
+      attr_accessor :mark
+      attr_accessor :temps
 
-      def day
-        ((elapsed_time_with_offset.to_f + 1) / DAY).ceil
-      end
+      attr_accessor :preset_temp
+      attr_accessor :room_temp
+      attr_accessor :room_psychrometry
 
-      def day_label
-        @brew.day_labels[day - 1]
-      end
+      attr_accessor :baume
+      attr_accessor :nihonshudo
+      attr_accessor :acid
+      attr_accessor :amino_acid
+      attr_accessor :alcohol
 
-      def elapsed_time_with_offset
-        @elapsed_time + @brew.day_offset
-      end
+      attr_accessor :warmings
+      attr_accessor :note
 
-      def baume
-        if @record.baume
-          @record.baume
-        elsif @record.nihonshudo
-          @record.nihonshudo * -0.1
-        end
+
+      def self.included(cls)
+        cls.prepend PrependMethods
       end
 
-      def nihonshudo
-        if @record.nihonshudo
-          @record.nihonshudo
-        elsif @record.baume
-          @record.baume * -10
+      module PrependMethods
+        def temps
+          (super || []).map(&:to_f)
         end
-      end
 
-      def display_baume
-        if @record.baume || @record.nihonshudo
-          b = baume
-          if b<3.0
-            nihonshudo
-          else
-            b
-          end
+        def temps=(val)
+          super([val].flatten.compact.map(&:to_f))
         end
-      end
 
-      def display_time(format="%m/%d %H:%M")
-        if @time
-          @time.strftime(format)
-        elsif @brew.min_time
-          time = @brew.min_time + @elapsed_time
-          time.strftime(format)
-        else
-          utc_offset = Time.at(0).utc_offset
-          Time.at(@elapsed_time - utc_offset).strftime(format)
+        def time=(val)
+          super(val&.to_time)
         end
-      end
 
-      def moromi_day
-        _tome_day = @brew.moromi_tome_day
-        _now_day = day
+        def warmings
+          super || []
+        end
 
-        if _tome_day && _tome_day < _now_day
-          _now_day - _tome_day + 1
+        def warmings=(val)
+          super([val].flatten.compact)
         end
       end
 
-      def bmd
-        _moromi_day = moromi_day
-        _baume = baume
+      module BaumeToNihonshudo
+        def nihonshudo
+          if self.baume
+            self.baume * -10
+          end
+        end
 
-        if _moromi_day && _baume
-          _moromi_day * _baume
+        def nihonshudo=(val)
+          if val
+            self.baume = val.to_f / -10.0
+          else
+            self.baume = nil
+          end
         end
       end
 
-      def expected_alcohol(target_alc, target_nihonshudo, coef)
-        _baume = baume
+      module NihonshudoToBaume
+        def baume
+          if self.nihonshudo
+            self.nihonshudo / -10.0
+          end
+        end
 
-        if _baume
-          target_alc - (_baume - target_nihonshudo * -0.1) * coef
+        def baume=(val)
+          if val
+            self.nihonshudo = val.to_f * -10
+          else
+            self.nihonshudo = nil
+          end
         end
       end
 
-      def to_h
-        {
-          elapsed_time: elapsed_time,
-          time: time,
-          mark: mark,
-          temps: temps,
-          preset_temp: preset_temp,
-          room_temp: room_temp,
-          room_psychrometry: room_psychrometry,
-          acid: acid,
-          amino_acid: amino_acid,
-          alcohol: alcohol,
-          warmings: warmings,
-          note: note,
-
-          day: day,
-          day_label: day_label,
-          elapsed_time_with_offset: elapsed_time_with_offset,
-          baume: baume,
-          nihonshudo: nihonshudo,
-          display_baume: display_baume,
-          display_time: display_time,
-          moromi_day: moromi_day,
-          bmd: bmd,
-        }
+      def self.create(val)
+        if State===val
+          val
+        elsif StateWrapper==val
+          val.state
+        #elsif Hash===val
+        #  #s = Class.new {
+        #  #  include State
+        #  #}.new
+        #  s = Object.new.tap {|o|
+        #    o.extend State
+        #    o.extend State::PrependMethods
+        #  }
+
+        #  KEYS.each {|k|
+        #    s.send("#{k}=", val[k])
+        #  }
+        #  s
+        else
+          raise Error, "ArgumentError: cant cast to Toji::Brew::State"
+        end
       end
     end
   end

data/lib/toji/brew/state_wrapper.rb

@@ -0,0 +1,135 @@
+require 'forwardable'
+
+module Toji
+  module Brew
+    class StateWrapper
+      extend Forwardable
+
+      attr_accessor :elapsed_time
+      attr_accessor :time
+      attr_reader :state
+      attr_reader :brew
+
+      def_delegators :@state, :mark
+      def_delegators :@state, :temps
+      def_delegators :@state, :preset_temp
+      def_delegators :@state, :room_temp
+      def_delegators :@state, :room_psychrometry
+      def_delegators :@state, :acid
+      def_delegators :@state, :amino_acid
+      def_delegators :@state, :alcohol
+      def_delegators :@state, :warmings
+      def_delegators :@state, :note
+
+      def initialize(elapsed_time, state, brew)
+        @elapsed_time = elapsed_time
+        @state = state
+        @brew = brew
+      end
+
+      def day
+        ((elapsed_time_with_offset.to_f + 1) / DAY).ceil
+      end
+
+      def day_label
+        @brew.day_labels[day - 1]
+      end
+
+      def elapsed_time_with_offset
+        @elapsed_time + @brew.day_offset
+      end
+
+      def baume
+        if @state.baume
+          @state.baume
+        elsif @state.nihonshudo
+          @state.nihonshudo * -0.1
+        end
+      end
+
+      def nihonshudo
+        if @state.nihonshudo
+          @state.nihonshudo
+        elsif @state.baume
+          @state.baume * -10
+        end
+      end
+
+      def display_baume
+        if @state.baume || @state.nihonshudo
+          b = baume
+          if b<3.0
+            nihonshudo
+          else
+            b
+          end
+        end
+      end
+
+      def display_time(format="%m/%d %H:%M")
+        if @time
+          @time.strftime(format)
+        elsif @brew.min_time
+          time = @brew.min_time + @elapsed_time
+          time.strftime(format)
+        else
+          utc_offset = Time.at(0).utc_offset
+          Time.at(@elapsed_time - utc_offset).strftime(format)
+        end
+      end
+
+      def moromi_day
+        _tome_day = @brew.moromi_tome_day
+        _now_day = day
+
+        if _tome_day && _tome_day < _now_day
+          _now_day - _tome_day + 1
+        end
+      end
+
+      def bmd
+        _moromi_day = moromi_day
+        _baume = baume
+
+        if _moromi_day && _baume
+          _moromi_day * _baume
+        end
+      end
+
+      def expected_alcohol(target_alc, target_nihonshudo, coef)
+        _baume = baume
+
+        if _baume
+          target_alc - (_baume - target_nihonshudo * -0.1) * coef
+        end
+      end
+
+      def to_h
+        {
+          elapsed_time: elapsed_time,
+          time: time,
+          mark: mark,
+          temps: temps,
+          preset_temp: preset_temp,
+          room_temp: room_temp,
+          room_psychrometry: room_psychrometry,
+          acid: acid,
+          amino_acid: amino_acid,
+          alcohol: alcohol,
+          warmings: warmings,
+          note: note,
+
+          day: day,
+          day_label: day_label,
+          elapsed_time_with_offset: elapsed_time_with_offset,
+          baume: baume,
+          nihonshudo: nihonshudo,
+          display_baume: display_baume,
+          display_time: display_time,
+          moromi_day: moromi_day,
+          bmd: bmd,
+        }
+      end
+    end
+  end
+end

data/lib/toji/calendar.rb

@@ -0,0 +1,123 @@
+require 'toji/calendar/date_row'
+require 'toji/calendar/date_column'
+
+module Toji
+  class Calendar
+    attr_reader :products
+
+    def initialize
+      @products = []
+    end
+
+    def <<(product)
+      @products << product
+      self
+    end
+    alias_method :add, :<<
+
+    def date_rows
+      events = @products.map{|product| product.events}.flatten
+
+      result = {}
+      events.each {|event|
+        result[event.date] ||= DateRow.new(event.date)
+        result[event.date] << event
+      }
+
+      result
+    end
+
+    def table_data
+      events = @products.map{|product| product.events}.flatten
+
+      koji_len = events.select{|e| e.type==:koji}.map(&:group_index).max + 1
+      kake_len = events.select{|e| e.type==:kake}.map(&:group_index).max + 1
+      min_date = events.map(&:date).min
+      max_date = events.map(&:date).max
+
+      headers = [:date]
+
+      case koji_len
+      when 1
+        headers += [:koji]
+      when 2
+        headers += [:moto_koji, :moromi_koji]
+      else
+        headers += [:moto_koji]
+        (2..koji_len).each {|i|
+          headers << "moromi_koji#{i-1}"
+        }
+      end
+
+      headers += [:moto, :soe, :naka, :tome, :yodan][0...kake_len]
+      (5...kake_len).each {|i|
+        headers << "#{i}dan"
+      }
+
+      _date_rows = date_rows
+
+      rows = []
+
+      date = min_date
+      while date<=max_date
+        columns = [date.strftime("%m/%d")]
+
+        date_row = _date_rows[date]
+        if date_row
+          koji_len.times {|i|
+            columns << (date_row.kojis[i]&.column_events || [])
+          }
+          kake_len.times {|i|
+            columns << (date_row.kakes[i]&.column_events || [])
+          }
+        else
+          (koji_len + kake_len).times {
+            columns << []
+          }
+        end
+
+        rows << columns
+
+        date = date.tomorrow
+      end
+
+      {header: headers, rows: rows}
+    end
+
+    def table_text_data
+      data = table_data
+      data[:rows] = data[:rows].map {|row|
+        row.map {|column|
+          if Array===column
+            column.map{|c|
+              name = c[:product].name
+              weight = "%.17g" % c[:weight]
+              "#{name}: #{weight}"
+            }.join("<br>")
+          else
+            column
+          end
+        }
+      }
+      data
+    end
+
+    def table
+      data = table_text_data
+
+      Plotly::Plot.new(
+        data: [{
+          type: :table,
+          header: {
+            values: data[:header]
+          },
+          cells: {
+            values: data[:rows].transpose
+          },
+        }],
+        layout: {
+        }
+      )
+    end
+  end
+end