toji 1.6.8 → 2.3.0

data/lib/toji/brew/graph/bmd.rb

@@ -5,7 +5,6 @@ module Toji
 
         def initialize
           @actuals = []
-          @expects = []
         end
 
         def actual(moromi, name=:actual)
@@ -17,7 +16,7 @@ module Toji
           result = []
 
           @actuals.each {|moromi, name|
-            states = moromi.states.select{|s| s.moromi_day && s.bmd}
+            states = moromi.wrapped_states.select{|s| s.moromi_day && s.bmd}
 
             xs = states.map(&:moromi_day).map{|d| d*DAY}
             ys = states.map(&:bmd)

data/lib/toji/brew/graph/multi_progress.rb

@@ -69,127 +69,6 @@ module Toji
             }
           )
         end
-
-        def state_group_order(group_by)
-          result = {}
-
-          @progresses.map{|progress|
-            progress.state_group_by(group_by)
-          }.map{|group|
-            group.map{|key,states|
-              [key, states.first.elapsed_time_with_offset]
-            }.to_h
-          }.each {|group|
-            result.merge!(group) {|key,self_val,other_val|
-              [self_val, other_val].min
-            }
-          }
-
-          result.sort_by(&:last).map(&:first)
-        end
-
-        def state_group_count(group_by)
-          result = {}
-
-          @progresses.map{|progress|
-            progress.state_group_count(group_by)
-          }.each {|group|
-            result.merge!(group) {|key,self_val,other_val|
-              [self_val, other_val].max
-            }
-          }
-
-          state_group_order(group_by).map {|val|
-            [val, result[val]]
-          }.to_h
-        end
-
-        def table_data(group_by=nil, keys=nil)
-          case group_by
-          when :elapsed_time, :elapsed_time_with_offset, nil
-            table_data_group_by_elapsed_time(keys)
-          else
-            table_data_group_by(group_by, keys)
-          end
-        end
-
-        def table_data_group_by(group_by, keys=nil)
-          header = []
-          cells = []
-
-          group_count = state_group_count(group_by)
-
-          header << ["", group_by]
-          cells << group_count.inject([]) {|result,(group,num)|
-            if 0<num
-              result << group
-              (num-1).times {
-                result << ""
-              }
-            end
-            result
-          }
-
-          @progresses.each {|progress|
-            data = progress.table_data(keys, group_by, group_count)
-            header += data[:header].map.with_index{|h,i|
-              name = i==0 ? progress.name : ""
-              [name, h]
-            }
-            cells += data[:rows].transpose
-          }
-
-          {header: header, rows: cells.transpose}
-        end
-
-        def table_data_group_by_elapsed_time(keys=nil, date_format="%m/%d %H:%M")
-          header = []
-          cells = []
-
-          elapsed_times = state_group_count(:elapsed_time_with_offset)
-
-          header << ["", :elapsed_time]
-          utc_offset = Time.at(0).utc_offset
-
-          cells << elapsed_times.inject([]) {|result,(elapsed_time,num)|
-            if 0<num
-              result << Time.at(elapsed_time - utc_offset).strftime(date_format)
-              (num-1).times {
-                result << ""
-              }
-            end
-            result
-          }
-
-          @progresses.each {|progress|
-            data = progress.table_data(keys, :elapsed_time_with_offset, elapsed_times)
-            header += data[:header].map.with_index{|h,i|
-              name = i==0 ? progress.name : ""
-              [name, h]
-            }
-            cells += data[:rows].transpose
-          }
-
-          {header: header, rows: cells.transpose}
-        end
-
-        def table(group_by=nil, keys=nil)
-          data = table_data(group_by, keys)
-
-          Plotly::Plot.new(
-            data: [{
-              type: :table,
-              header: {
-                values: data[:header]
-              },
-              cells: {
-                values: data[:rows].transpose
-              },
-            }],
-            layout: {
-            }
-          )
-        end
       end
     end
   end

data/lib/toji/brew/graph/progress.rb

@@ -75,7 +75,7 @@ module Toji
             result << {x: xs, y: ys, text: text, name: "#{name}#{key}", line: {dash: @dash, shape: line_shape}, marker: {color: PLOT_COLORS[key]}}
           }
 
-          if 0<@brew.states.length && 0<@brew.day_offset
+          if 0<@brew.wrapped_states.length && 0<@brew.day_offset
             result = result.map{|h|
               h[:x].unshift(0)
               h[:y].unshift(nil)
@@ -84,8 +84,8 @@ module Toji
             }
           end
 
-          #if 0<@brew.states.length && @brew.states.last.time.strftime("%T")!="00:00:00"
-          #  t = @brew.states.last.elapsed_time_with_offset
+          #if 0<@brew.wrapped_states.length && @brew.wrapped_states.last.time.strftime("%T")!="00:00:00"
+          #  t = @brew.wrapped_states.last.elapsed_time_with_offset
           #  t -= (t % DAY) - DAY
           #
           #  result = result.map{|h|
@@ -100,7 +100,7 @@ module Toji
         end
 
         def annotations
-          return [] if @enable_annotations
+          return [] if !@enable_annotations
 
           @brew.select{|s| s.mark}.map {|s|
             {
@@ -117,28 +117,7 @@ module Toji
           }
         end
 
-        def state_group_by(group_by)
-          group = {}
-          prev = nil
-
-          @brew.each {|state|
-            val = state.send(group_by) || prev
-            prev = val
-
-            group[val] ||= []
-            group[val] << state
-          }
-
-          group
-        end
-
-        def state_group_count(group_by)
-          state_group_by(group_by).map{|val,states|
-            [val, states.length]
-          }.to_h
-        end
-
-        def table_data(keys=nil, group_by=nil, group_count=nil)
+        def table_data(keys=nil)
           if !keys
             keys = @brew.has_keys
             keys.delete(:elapsed_time)
@@ -151,33 +130,19 @@ module Toji
             keys &= @brew.has_keys
           end
 
-          if group_by && group_count
-            brew_hash = state_group_by(group_by)
-          else
-            group_count = state_group_count(:itself)
-            brew_hash = state_group_by(:itself)
-          end
-
           rows = []
-          group_count.each {|group_value,num|
-            states = brew_hash[group_value] || []
-            num ||= states.length
-
-            num.times {|i|
-              state = states[i]
-
-              rows << keys.map {|k|
-                v = state&.send(k)
-                if Array===v
-                  v.map(&:to_s).join(", ")
-                elsif Float===v
-                  v.round(3)
-                elsif v
-                  v
-                else
-                  ""
-                end
-              }
+          @brew.each {|state|
+            rows << keys.map {|k|
+              v = state&.send(k)
+              if Array===v
+                v.map(&:to_s).join(", ")
+              elsif Float===v
+                v.round(3).to_s
+              elsif v
+                v.to_s
+              else
+                ""
+              end
             }
           }
 

data/lib/toji/brew/koji.rb

@@ -1,16 +1,7 @@
 module Toji
   module Brew
-    class Koji < Base
-
-      state_reader :hikikomi
-      state_reader :tokomomi
-      state_reader :kirikaeshi
-      state_reader :mori
-      state_reader :naka_shigoto
-      state_reader :shimai_shigoto
-      state_reader :tsumikae
-      state_reader :dekoji
-
+    module Koji
+      include Base
 
       def progress(name: nil, dash: :solid, enable_annotations: true)
         Graph::Progress.new(self, name: name, dash: dash, enable_annotations: enable_annotations)

data/lib/toji/brew/moromi.rb

@@ -1,42 +1,9 @@
 module Toji
   module Brew
-    class Moromi < Base
+    module Moromi
+      include Base
 
-      state_reader :moto
-      state_reader :soe
-      state_reader :naka
-      state_reader :tome
-      state_reader :yodan
-
-      attr_writer :prefix_day_labels
-
-      def prefix_day_labels
-        if @prefix_day_labels
-          @prefix_day_labels
-        elsif !self[:soe] && !self[:tome]
-          nil
-        else
-          labels = []
-          [:soe, :naka, :tome].each {|mark|
-            s = self[mark]
-            if s
-              i = s.day - 1
-              labels[i] = mark
-            end
-          }
-
-          soe_i = labels.index(:soe)
-          labels.map.with_index {|label,i|
-            if label
-              label
-            elsif !soe_i || i<soe_i
-              :moto
-            else
-              :odori
-            end
-          }
-        end
-      end
+      attr_accessor :prefix_day_labels
 
       def moromi_tome_day
         prefix_day_labels&.length
@@ -57,7 +24,7 @@ module Toji
         if _prefix
           _prefix + moromi_days.times.map{|i| i+2}.map(&:to_s)
         else
-          self.days.times.map{|i| i+1}.map(&:to_s)
+          super
         end
       end
 

data/lib/toji/brew/shubo.rb

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

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 WrappedState==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