toji 1.6.8 → 2.0.0

data/lib/toji/recipe/yeast_rate.rb

@@ -1,41 +0,0 @@
-module Toji
-  module Recipe
-    class YeastRate
-
-      # 1リットル醸造のために必要な酵母の量
-      attr_reader :yeast_rate
-
-      # 乾燥酵母を戻すのに必要な水の量
-      attr_reader :water_rate
-
-      def initialize(yeast_rate, water_rate)
-        @yeast_rate = yeast_rate
-        @water_rate = water_rate
-      end
-
-      # RedStar酵母
-      #
-      # 容量        5g
-      # 醸造可能量  20〜23L
-      #
-      # ドライイーストは、生イーストの保存性を高めるために、その水分を大部分除いたものです。
-      # 使用時にはイーストの10倍以上の30-35℃の無菌のお湯（ミネラルウオーターや湯冷まし）で20-25分程度なじませてください。
-      # これにより水分を再吸収させると同 時に発酵力を回復させ、生イーストの状態にもどします。
-      # このときの温湯の温度が、イーストの発酵力に影響します
-      RED_STAR = new(5.0 / 20.0, 10.0)
-
-      # 酒粕
-      #
-      # 以下の計算式を用いて酒粕にどの程度水を足せば醪時点での緩さになるかを算出する。
-      # 計算が面倒なので麹歩合は無視して蒸米時点での重量とする。
-      #  (白米重量 * 蒸米歩合 + 白米重量 * 汲水歩合) / (粕歩合 * 100) - 1
-      #
-      # 蒸米歩合135%、汲水歩合130%、粕歩合30%の場合、酒粕に対して7.833倍の水を足せば理論上醪と同じ緩さになる。
-      #  (100 * 1.35 + 100 * 1.3) / (0.3 * 100) - 1
-      #   => 7.833333333333334
-      #
-      # しかし櫂入れ出来る程度の緩さになれば良いのではないだろうか。
-      SAKE_LEES = new(5.0, 3.0)
-    end
-  end
-end

data/lib/toji/schedule.rb

@@ -1,11 +0,0 @@
-require 'toji/schedule/calendar'
-require 'toji/schedule/product'
-require 'toji/schedule/product_event'
-require 'toji/schedule/date_row'
-require 'toji/schedule/date_column'
-require 'toji/schedule/date_interval_enumerator'
-
-module Toji
-  module Schedule
-  end
-end

data/lib/toji/schedule/calendar.rb

@@ -1,139 +0,0 @@
-module Toji
-  module Schedule
-    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
-        rice_len = events.select{|e| e.type==:rice}.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...rice_len]
-        (5...rice_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]&.to_h_a || [])
-            }
-            rice_len.times {|i|
-              columns << (date_row.rices[i]&.to_h_a || [])
-            }
-          else
-            (koji_len + rice_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
-
-      def self.load_hash(hash)
-        hash = hash.deep_symbolize_keys
-        products = hash[:products] || []
-
-        cal = new
-        products.each {|product|
-          cal.add(Product.create(product))
-        }
-
-        cal
-      end
-
-      def self.load_yaml_file(fname)
-        hash = YAML.load_file(fname)
-        load_hash(hash)
-      end
-    end
-  end
-end

data/lib/toji/schedule/date_interval_enumerator.rb

@@ -1,45 +0,0 @@
-module Toji
-  module Schedule
-    class DateIntervalEnumerator
-      include Enumerable
-
-      def initialize(intervals, afterwards)
-        @intervals = intervals
-        @afterwards = afterwards
-      end
-
-      def each(&block)
-        Enumerator.new do |y|
-          y << 0
-          @intervals.each {|interval|
-            y << interval
-          }
-          loop {
-            y << @afterwards
-          }
-        end.each(&block)
-      end
-
-      def merge(dates, length)
-        dates = [dates].flatten
-        enum = each
-
-        length.times {|i|
-          add = enum.next
-
-          if i==0
-            dates[i] = dates[i].to_time
-          elsif Integer===dates[i] && dates[i-1]
-            dates[i] = dates[i-1].since(dates[i].days)
-          elsif !dates[i] && dates[i-1]
-            dates[i] = dates[i-1].since(add.days)
-          else
-            dates[i] = dates[i].to_time
-          end
-        }
-
-        dates
-      end
-    end
-  end
-end

data/lib/toji/schedule/product.rb

@@ -1,117 +0,0 @@
-module Toji
-  module Schedule
-    class Product
-      attr_reader :id
-      attr_reader :name
-      attr_reader :description
-      attr_reader :recipe
-
-      attr_reader :koji_dates
-      attr_reader :rice_dates
-
-      attr_reader :color
-
-      def initialize(id, name, description, recipe, koji_dates, rice_dates, color=nil)
-        @id = id
-        @name = name
-        @description = description
-        @recipe = recipe
-
-        @koji_dates = DateIntervalEnumerator.new([], 0).merge(koji_dates, recipe.steps.length)
-        @rice_dates = DateIntervalEnumerator.new([recipe.moto_days, recipe.odori_days+1, 1], 1).merge(rice_dates, recipe.steps.length)
-
-        @color = color
-      end
-
-      def events
-        events = []
-
-        @koji_dates.length.times {|i|
-          events << ProductEvent.new(self, :koji, i)
-        }
-
-        @rice_dates.length
-          .times.map {|i|
-            ProductEvent.new(self, :rice, i)
-          }
-          .delete_if {|e|
-            4<=e.index && e.weight==0
-          }
-          .each {|e|
-            events << e
-          }
-
-        events
-      end
-
-      def events_group
-        events.group_by{|event|
-          event.group_key
-        }.map {|group_key,events|
-          breakdown = events.map {|event|
-            {index: event.index, weight: event.weight}
-          }
-          if 1<breakdown.length
-            breakdown = breakdown.select{|event| 0<event[:weight]}
-          end
-
-          {
-            date: events.first.date,
-            type: events.first.type,
-            weight: events.map(&:weight).sum,
-            breakdown: breakdown,
-          }
-        }
-      end
-
-      def to_h
-        {
-          id: @id,
-          name: @name,
-          description: @description,
-          recipe: @recipe.table_data,
-          koji_dates: @koji_dates,
-          rice_dates: @rice_dates,
-          events: events.map(&:to_h),
-          events_group: events_group,
-          color: @color,
-        }
-      end
-
-      def self.create(args)
-        if self===args
-          args
-        elsif Hash===args
-          recipe = args.fetch(:recipe)
-          if Symbol===recipe
-            recipe = Recipe::ThreeStepMashing::TEMPLATES.fetch(recipe)
-          end
-          if args[:scale]
-            recipe = recipe.scale(args[:scale])
-          end
-          if args[:round]
-            recipe = recipe.round(args[:round])
-          end
-          if args[:moto_days]
-            recipe.moto_days = args[:moto_days]
-          end
-          if args[:odori_days]
-            recipe.odori_days = args[:odori_days]
-          end
-
-          new(
-            args[:id],
-            args[:name],
-            args[:description],
-            recipe,
-            args[:koji_dates],
-            args[:rice_dates],
-            args[:color]
-          )
-        else
-          raise "not supported class: #{args.class}"
-        end
-      end
-    end
-  end
-end