smcty 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 066404cac54ab6ea59d05f19655509a73fe25879
+  data.tar.gz: 9fb49f6ed6a8d580f4f63d8558ce012b5ebc1fab
+SHA512:
+  metadata.gz: 79c2493d00915a80980b58991bd7f13a38fdb5f0fd5ebb79884c29f09cbcb584d359824b01085a5a7488a1a458c5bd5d27659f130cae8cda89751e0d13a9e969
+  data.tar.gz: dde05154fcd122b9f13c0907716bfb8f0cebfdcad6b4a8756bcdf8238ab3407deb760266b556bcbb20eabb848fa1504b4bc075ad38ac8c294c05a011abd7e5a3

data/bin/smcty

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'smcty'
+Smcty::Planner.start(ARGV[0])

data/lib/smcty.rb

@@ -0,0 +1 @@
+require 'smcty/planner'

data/lib/smcty/allocation.rb

@@ -0,0 +1,26 @@
+module Smcty
+  class Allocation
+    attr_reader :store, :resource, :amount
+
+    def initialize(store, resource, amount)
+      @store = store
+      @resource = resource
+      @amount = amount
+    end
+
+    def valid?
+      @store.valid?(self)
+    end
+
+    def get
+      @store.get(self)
+    end
+
+    def to_hash
+      {
+        "resource" => @resource.name,
+        "amount" => @amount
+      }
+    end
+  end
+end

data/lib/smcty/configuration.rb

@@ -0,0 +1,61 @@
+module Smcty
+  class Configuration
+    attr_reader :created_at, :store, :scheduler
+
+    def initialize(store)
+      @created_at = Time.new
+      @store = store
+      @factories = {}
+      @scheduler = Scheduling.new(self)
+    end
+
+    def register_factory(factory)
+      @factories[factory.name] = factory
+    end
+
+    def resource_by_name(resource_name)
+      @factories.values.each do |factory|
+        resource = factory.resource_by_name(resource_name)
+        return resource if resource
+      end
+      nil
+    end
+
+    def resources
+      result = []
+      @factories.values.each do |f|
+        result += f.resources
+      end
+      result
+    end
+
+    def factory_for(resource)
+      @factories.values.each do |factory|
+        found = factory.resource_by_name(resource.name)
+        return factory if found
+      end
+      nil
+    end
+
+    def factories
+      @factories.keys.sort
+    end
+
+    def factory(name)
+      @factories[name]
+    end
+
+    def to_s
+      "Configuration created at #{@created_at}"
+    end
+
+    def to_hash
+      {
+        "store" => @store.to_hash,
+        "factories" => @factories.values.map{|f| f.to_hash},
+        "scheduling" => @scheduler.to_hash
+      }
+    end
+
+  end
+end

data/lib/smcty/configurator.rb

@@ -0,0 +1,178 @@
+require 'json'
+
+require 'smcty/store'
+require 'smcty/configuration'
+require 'smcty/factory'
+require 'smcty/resource'
+
+module Smcty
+  class Configurator
+    attr_reader :configuration
+
+    def initialize(config_path)
+      @config_path = config_path
+      @configuration = Configurator.read_configuration(config_path)
+    end
+
+    def save
+      Configurator.write_configuration(@configuration, @config_path)
+    end
+
+    def self.read_configuration(path)
+      file = File.read(path)
+      data_hash = JSON.parse(file)
+
+      if (data_hash && data_hash != {})
+        store_hash = read_value(data_hash, "store", true)
+        store_name = read_value(store_hash, "name", true)
+        store_capacity = read_value(store_hash, "capacity", true)
+        store = Store.new(store_name, store_capacity)
+
+        configuration = Configuration.new(store)
+
+        deferred_dependencies = []
+
+        factories_list = read_value(data_hash, "factories", true)
+        factories_list.each do |factory_hash|
+          factory_name = read_value(factory_hash, "name", true)
+          factory_capacity = read_value(factory_hash, "capacity", true)
+          factory_sequential = read_value(factory_hash, "sequential", false, false)
+
+          factory = Factory.new(factory_name, factory_capacity, factory_sequential)
+          configuration.register_factory(factory)
+
+          factory_resources = read_value(factory_hash, "resources", true)
+          factory_resources.each do |resources_hash|
+            resource_name = read_value(resources_hash, "name", true)
+            resource_description = read_value(resources_hash, "description", true)
+            resource_time = read_value(resources_hash, "time", true)
+
+            resource = Resource.new(resource_name, resource_description)
+            factory.register_resource(resource, resource_time)
+
+            resource_deps = read_value(resources_hash, "deps", false, [])
+            resource_deps.each do |dependency_hash|
+              dependency_name = read_value(dependency_hash, "name", true)
+              dependency_amount = read_value(dependency_hash, "amount", true)
+
+              if dep_resource = configuration.resource_by_name(dependency_name)
+                resource.register_dependency(dep_resource, dependency_amount)
+              else
+                deferred_dependencies << {resource: resource,
+                  dependency_name: dependency_name,
+                  dependency_amount: dependency_amount
+                }
+              end
+            end
+          end
+        end
+
+        # post process deferred dependencies
+        deferred_dependencies.each do |deferred_dep|
+          resource = deferred_dep[:resource]
+          dependency_name = deferred_dep[:dependency_name]
+          amount = deferred_dep[:dependency_amount]
+
+          dependent_resource = configuration.resource_by_name(dependency_name)
+          unless dependent_resource
+            raise "Cannot fullfill dependency from #{resource.name} -> #{dependency_name}"
+          end
+
+          resource.register_dependency(dependent_resource, amount)
+        end
+
+        # post process stock of store
+        read_value(store_hash, "stock", false, []).each do |stock_hash|
+          resource_name = read_value(stock_hash, "name", true)
+          resource_amount = read_value(stock_hash, "amount", true)
+
+          resource = configuration.resource_by_name(resource_name) || Resource.new(resource_name, "unmanaged")
+          store.put(resource, resource_amount)
+        end
+
+        # post process the scheduling information
+        scheduling_hash = read_value(data_hash, "scheduling", true)
+        read_value(scheduling_hash, "projects", false, []).each do |project_hash|
+          project_name = read_value(project_hash, "name", true)
+          project = Project.new(project_name)
+          read_value(project_hash, "requirements", true).each do |req|
+            resource_name = read_value(req, "resource", true)
+            amount = read_value(req, "amount", true).to_i
+            resource = configuration.resource_by_name(resource_name)
+            unless resource
+              raise "Cannot register requirement for unknown resource #{resource_name}"
+            end
+            project.add_requirement(resource, amount)
+          end
+
+          job_dict = {}
+          job_dependencies = {}
+          jobs = []
+
+          # first pass to create the single jobs
+          read_value(project_hash, "jobs", true).each do |job_hash|
+            reference = read_value(job_hash, "id", true)
+            resource_name = read_value(job_hash, "resource", true)
+            resource = configuration.resource_by_name(resource_name)
+            unless resource
+              raise "Cannot create job for unknown resource #{resource_name}"
+            end
+            job = Job.new(resource)
+            job_dict[reference] = job
+            jobs << job
+
+            allocation_hash = read_value(job_hash, "allocation", false, nil)
+            if allocation_hash
+              amount = read_value(allocation_hash, "amount", true).to_i
+              allocation = store.allocate(resource, amount)
+              job.allocate(allocation) if allocation
+            end
+
+            production_hash = read_value(job_hash, "production", false, nil)
+            if production_hash
+              start_time = read_value(production_hash, "start_time", true).to_i
+              duration = read_value(production_hash, "duration", true).to_i
+              production = Production.new(resource, duration, start_time)
+              job.produce(production)
+            end
+
+            dependency_list = read_value(job_hash, "dependent_jobs", false, nil)
+            job_dependencies[job] = dependency_list if dependency_list
+          end
+
+          # second pass to connect dependent jobs
+          job_dependencies.keys.each do |job|
+            job_dependencies[job].each do |dep_ref|
+              dep_job = job_dict[dep_ref]
+              unless dep_job
+                raise "job references another job which is not known (#{dep_ref})"
+              end
+              job.add_dependent(dep_job)
+            end
+          end
+
+          configuration.scheduler.load_project(project, jobs)
+        end
+
+        configuration
+      end
+    end
+
+    def self.write_configuration(configuration, path)
+      File.open(path,"w") do |f|
+        f.write(configuration.to_hash.to_json)
+      end
+    end
+
+    private
+
+    def self.read_value(hash, key, force, default=nil)
+      value = hash[key]
+      if force && (value == nil)
+        raise "The hash #{hash} does not contain the key #{key}"
+      end
+      value || default
+    end
+
+  end
+end

data/lib/smcty/console.rb

@@ -0,0 +1,229 @@
+require 'smcty/configurator'
+require 'smcty/output'
+require 'smcty/helpers'
+require 'smcty/production'
+require 'smcty/project'
+require 'smcty/scheduling'
+
+module Smcty
+  class Console
+
+    # Initialize the console with the input stream (e.g. $stdin)
+    # and a path to smcty configuration file.
+    def initialize(input_stream, config_path)
+      @in = input_stream
+      @configurator = Configurator.new(config_path)
+      @configuration = @configurator.configuration
+      @productions = {}
+
+    end
+
+    def prompt!
+      run = true
+      while run
+        "-> ".display
+        run = dispatch(@in.gets.chomp)
+      end
+    end
+
+    # Commands
+    #
+    #   quit
+    #
+    #   store                   -> list the inventory of the store
+    #   store put #item #amount
+    #
+    #   factory                 -> list the registered factories
+    #   factory #name           -> list the resources and the production of the named factory
+    #
+    #   resources               -> list all managed resources
+    #
+    #   project add #label [#resource:#amount]+
+    #   project #label
+    #
+    #   produce #resource
+    #
+    #   pick #production-number
+    #
+    #   next
+    #
+    def dispatch(input)
+      continue = true
+      commands = input.split(" ")
+      case commands[0].downcase
+      when "store"
+        continue = process_store(commands[1..-1])
+      when "factory"
+        continue = process_factory(commands[1..-1])
+      when "quit"
+        continue = process_quit
+      when "resources"
+        continue = process_resources
+      when "project"
+        continue = process_projects(commands[1..-1])
+      when "produce"
+        continue = process_production(commands[1..-1])
+      when "pick"
+        continue = process_pick(commands[1..-1])
+      when "next"
+        continue = process_next
+      when "save"
+        continue = process_save
+      when "scheduling"
+        continue = process_scheduling
+      else
+        puts "unknown command: #{input}"
+      end
+      return continue
+    end
+
+    def process_scheduling
+      @configuration.scheduler.print_job_lists
+      true
+    end
+
+    def process_next
+      puts "DO > #{@configuration.scheduler.next}"
+      true
+    end
+
+    def process_projects(commands)
+      if commands.size == 1
+        puts "print the project"
+      elsif commands.size > 2
+        unless commands[0] == "add"
+          puts "unknow command #{commands[0]} for project is not known"
+          return true
+        end
+        project = Project.new(commands[1])
+        requirements = commands[2..-1]
+        requirements.each do |r|
+          items = r.split(":")
+          r_name = items[0]
+          amount = items[1].to_i
+          resource = @configuration.resource_by_name(r_name)
+          unless resource
+            puts "the resource #{resource_name} is not known"
+            return true
+          end
+          project.add_requirement(resource, amount)
+        end
+        @configuration.scheduler.plan_project(project)
+        puts "planned the project"
+      else
+        puts "not enough parameters for project command"
+      end
+      true
+    end
+
+    def process_pick(commands)
+      if commands.size != 1
+        puts "please pass the number of production to pick"
+      else
+        number = commands[0].to_i
+        production = @productions[number]
+        unless production
+          puts "the production number #{commands[0]} is not known"
+          return true
+        end
+        unless production.finished?
+          puts "the production is not finished yet"
+          return true
+        end
+        if @configuration.store.free_capacity > 0
+          factory = @configuration.factory_for(production.resource)
+          factory.pick(production)
+          @productions.delete(number)
+          @configuration.store.put(production.resource, 1)
+          puts "the item was stored"
+        else
+          puts "no storage left"
+        end
+      end
+      true
+    end
+
+    def process_production(commands)
+      if commands.size != 1
+        puts "please name the resource to produce"
+      else
+        resource_name = commands[0]
+        resource = @configuration.resource_by_name(resource_name)
+        unless resource
+          puts "the resource #{resource_name} is not known"
+          return true
+        end
+        factory = @configuration.factory_for(resource)
+        allocations = []
+        resource.dependent_resources.each do |r|
+          allocation = @configuration.store.allocate(r, resource.dependent_resource_amount(r))
+          unless allocation
+            puts "Not enough of #{r.name} to produce #{resource_name}"
+            return true
+          end
+          allocations << allocation
+        end
+        production = factory.produce(resource, allocations)
+        @productions[production.object_id] = production
+        puts "Now producing: #{production.object_id} in factory: #{factory.name}"
+      end
+      true
+    end
+
+    def process_resources
+      list_resources(@configuration.resources)
+      true
+    end
+
+    def process_quit
+      puts "Storing configuration back to file and exit."
+      @configurator.save
+      false
+    end
+
+    def process_save
+      puts "Storing configuration back to file"
+      @configurator.save
+      true
+    end
+
+    def process_store(commands)
+      if commands.size == 0
+        list_inventory(@configuration.store)
+      elsif commands.size == 3
+        resource = @configuration.resource_by_name(commands[1])
+        amount = commands[2].to_i
+        if resource && amount > 0
+          case commands[0].downcase
+          when "put"
+            puts "put #{commands[2]} units of #{commands[1]} to store"
+            result = @configuration.store.put(resource, amount)
+            puts "new stock is: #{@configuration.store.stock(resource)}"
+          else
+            puts "operator on store was not recognized"
+          end
+        else
+          puts "resource '#{commands[1]}' or amount '#{commands[2]}' not valid"
+        end
+      else
+        puts "command not recognized"
+      end
+      true
+    end
+
+    def process_factory(commands)
+      if commands.size == 0
+        list_factories(@configuration.factories)
+      else
+        factory = @configuration.factory(commands[0])
+        if factory
+          list_factory(factory)
+        else
+          puts "The factory '#{commands[0]}' is not registered"
+        end
+      end
+      true
+    end
+
+  end
+end

data/lib/smcty/factory.rb

@@ -0,0 +1,105 @@
+module Smcty
+  class Factory
+    attr_reader :name, :capacity, :productions, :sequential
+
+    def initialize(name, capacity, sequential=false)
+      @name = name
+      @capacity = capacity
+      @resources = {}
+      @production_times = {}
+      @productions = []
+      @sequential = sequential
+    end
+
+    def free_capacity
+      capacity - @productions.size
+    end
+
+    def register_resource(resource, production_time)
+      @production_times[resource] = production_time
+      @resources[resource.name] = resource
+    end
+
+    def resources
+      @production_times.keys
+    end
+
+    def production_time(resource)
+      @production_times[resource]
+    end
+
+    def resource_by_name(name)
+      @resources[name]
+    end
+
+    def produce(resource, allocations=[])
+      unless free_capacity > 0
+        raise "The factory has no capacity for further production"
+      end
+
+      unless Factory.check_preconditions(resource, allocations)
+        raise "The preconditions for this production aren't met"
+      end
+
+      time = @production_times[resource]
+      unless time
+        raise "The resource #{resource.name} is not registered with this factory"
+      end
+
+      # in case of a sequential production the time must be extended
+      # find latest end time of a preceeding production
+      if sequential && latest = @productions.sort{|x,y| y.end_time <=> x.end_time}.first
+        time += (latest.end_time - Time.now).to_i
+      end
+
+      allocations.each{ |a| a.get }
+      production = Production.new(resource, time)
+      @productions << production
+      production
+    end
+
+    def pick(production)
+      if production && production.finished?
+        @productions.delete(production)
+      end
+    end
+
+    def to_s
+      "Factory '#{@name}' with capacity of #{@capacity} is responsible for #{@resources.keys.join(", ")}"
+    end
+
+    def to_hash
+      {
+        "name" => @name,
+        "capacity" => @capacity,
+        "sequential" => @sequential,
+        "resources" => @resources.values.map{|r| r.to_hash(@production_times[r])}
+      }
+    end
+
+    private
+
+    def self.check_preconditions(resource, allocations)
+      allocated_resources = {}
+      allocations.each do |a|
+        if a.valid?
+          depot = allocated_resources[a.resource] || {amount: 0}
+          depot[:amount] += a.amount
+          allocated_resources[a.resource] = depot
+        end
+      end
+
+      resource.dependent_resources.each do |dr|
+        required_amount = resource.dependent_resource_amount(dr)
+        depot = allocated_resources[dr]
+        if depot && depot[:amount] >= required_amount
+          depot[:amount] -= required_amount
+        else
+          return false
+        end
+      end
+      return true
+    end
+
+  end
+end

data/lib/smcty/helpers.rb

@@ -0,0 +1,16 @@
+def natural_time(time)
+  unit = time
+
+  # given unit in seconds
+  hours = unit / 3600
+  unit = unit - (hours * 3600)
+
+  minutes = unit / 60
+  seconds = unit - (minutes * 60)
+
+  result =  (hours > 0) ? "#{hours}h " : ""
+  result += (minutes > 0) ? "#{minutes}m " : ""
+  result += "#{seconds}s"
+
+  result.strip
+end

data/lib/smcty/job.rb

@@ -0,0 +1,72 @@
+module Smcty
+  class Job
+    attr_reader :resource, :allocation, :production, :dependent_jobs
+
+    def initialize(resource)
+      @resource = resource
+      @used = false
+      @dependent_jobs = []
+    end
+
+    def allocate(allocation)
+      @allocation = allocation
+      @production = nil
+    end
+
+    def produce(production)
+      @allocation = nil
+      @production = production
+    end
+
+    def add_dependent(job)
+      @dependent_jobs << job
+    end
+
+    def reset_dependent_jobs
+      @dependent_jobs = []
+    end
+
+    def dependencies?
+      @dependent_jobs.size > 0
+    end
+
+    def allocated?
+      @allocation != nil
+    end
+
+    def in_production?
+      @production != nil && !@production.finished?
+    end
+
+    def ready?
+      @production != nil && @production.finished?
+    end
+
+    def new?
+      @allocation == nil && @production == nil && @dependent_jobs.size == 0
+    end
+
+    def allocated_dependencies?
+      if dependencies?
+        @dependent_jobs.each do |job|
+          return false unless job.allocated?
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    def to_hash
+      core_hash = {
+        "id" => self.object_id,
+        "resource" => @resource.name,
+      }
+      core_hash["allocation"] = @allocation.to_hash if @allocation
+      core_hash["production"] = @production.to_hash if @production
+      core_hash["dependent_jobs"] = @dependent_jobs.map{|j| j.object_id} if @dependent_jobs.size > 0
+      core_hash
+    end
+
+  end
+end

data/lib/smcty/output.rb

@@ -0,0 +1,71 @@
+def list_inventory(store)
+  puts "---------------------------------------------------------------------------------------"
+  puts store.to_s
+  puts "---------------------------------------------------------------------------------------"
+  puts "Current inventory:"
+  puts ""
+  store.inventory.each do |item|
+    puts "\t#{item.name}: #{store.available_stock(item)} items (allocated: #{store.allocated_stock(item)})"
+  end
+end
+
+def list_resources(resource_list)
+  puts "-------------------------------------------------------------------"
+  puts "Registered Resources:"
+  puts ""
+  resource_list.each do |r|
+    puts "\t#{r.to_s}"
+  end
+end
+
+def list_project(project)
+  puts "-------------------------------------------------------------------"
+  puts "Project #{project.name}"
+  puts ""
+  project.resources.each do |r|
+    puts "\t#{r.name} - #{project.amount(r)}"
+  end
+end
+
+def list_factories(factory_list)
+  puts "-------------------------------------------------------------------"
+  puts "Registered Factories:"
+  puts ""
+  factory_list.each do |f|
+    puts "\t#{f.to_s}"
+  end
+end
+
+def list_factory(factory)
+  puts "-------------------------------------------------------------------"
+  puts factory.to_s
+  puts "sequential: #{factory.sequential}"
+  puts "-------------------------------------------------------------------"
+  puts "Available resources:"
+  puts ""
+  factory.resources.each do |resource|
+    puts "\t#{resource.to_s} (Time: #{natural_time(factory.production_time(resource))})"
+  end
+  puts ""
+  puts "Running production"
+  factory.productions.each do |production|
+    line = "\t#{production.object_id} -> #{production.resource.name}"
+    line += " / started at: #{production.start_time}"
+    line += " / duration: #{production.duration}"
+    line += " / delivery at: #{production.start_time + production.duration}"
+    line + " / finished: #{production.finished?}"
+    puts line
+  end
+end
+
+def list_configuration(configuration)
+  puts "==================================================================="
+  puts "Configuration created at: #{configuration.created_at}"
+  puts "==================================================================="
+  puts ""
+  list_inventory(configuration.store)
+  configuration.factories.each do |factory_name|
+    puts ""
+    outline_factory(configuration.factory(factory_name))
+  end
+end

data/lib/smcty/planner.rb

@@ -0,0 +1,13 @@
+require 'smcty/console'
+
+module Smcty
+  class Planner
+    def self.start(path)
+      puts "Starting Simcity Production Assistent"
+      puts "> load configuration from #{path}"
+
+      console = Console.new($stdin, path)
+      console.prompt!
+    end
+  end
+end

data/lib/smcty/production.rb

@@ -0,0 +1,31 @@
+module Smcty
+  class Production
+    attr_reader :start_time, :duration, :resource
+
+    def initialize(resource, duration, start_time=nil)
+      @start_time = start_time ? Time.at(start_time) : Time.now
+      @duration = duration
+      @resource = resource
+    end
+
+    def finished?
+      end_time <= Time.now
+    end
+
+    def end_time
+      @start_time + duration
+    end
+
+    def to_s
+      "Production of #{resource.name} since #{@start_time} takes #{natural_time(@duration)} (Finished: #{finished?})"
+    end
+
+    def to_hash
+      {
+        "start_time" => @start_time.to_i,
+        "duration" => @duration,
+        "resource" => @resource.name
+      }
+    end
+  end
+end

data/lib/smcty/project.rb

@@ -0,0 +1,23 @@
+module Smcty
+  class Project
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @requirements = {}
+    end
+
+    def resources
+      @requirements.keys
+    end
+
+    def amount(resource)
+      @requirements[resource]
+    end
+
+    def add_requirement(resource, amount)
+      @requirements[resource] = amount
+    end
+
+  end
+end

data/lib/smcty/resource.rb

@@ -0,0 +1,46 @@
+module Smcty
+  class Resource
+    attr_reader :name, :description
+
+    def initialize(name, description)
+      @name = name
+      @description = description
+      @dependencies = {}
+    end
+
+    def register_dependency(resource, amount)
+      @dependencies[resource] = amount
+    end
+
+    def dependent_resources
+      @dependencies.keys
+    end
+
+    def dependent_resource_amount(resource)
+      @dependencies[resource]
+    end
+
+    def to_s
+      "Resource '#{@name}' (#{@description}) with these dependencies: #{dependency_list}"
+    end
+
+    def to_hash(time)
+      {
+        "name" => @name,
+        "description" => @description,
+        "time" => time,
+        "deps" => @dependencies.keys.map{|r| {"name" => r.name, "amount" => @dependencies[r]}}
+      }
+    end
+
+    private
+
+    def dependency_list
+      items = []
+      @dependencies.keys.each do |resource|
+        items << "#{resource.name}: #{@dependencies[resource]}"
+      end
+      items.join(", ")
+    end
+  end
+end

data/lib/smcty/scheduling.rb

@@ -0,0 +1,198 @@
+require 'smcty/job'
+
+module Smcty
+  class Scheduling
+
+    def initialize(configuration)
+      @configuration = configuration
+      @projects = {}
+    end
+
+    def plan_project(project)
+      jobs = []
+      @projects[project] = jobs
+
+      # 1. split the requirements into jobs
+      project.resources.each do |r|
+        project.amount(r).times do
+          jobs << Job.new(r)
+        end
+      end
+
+      # 2. work through initial job list and either
+      #   - allocate available resources
+      #   - add jobs to produce dependent jobs
+      # and iterate until the list does not change any more.
+      #
+      prev_size = 0
+      while (jobs.size != prev_size) do
+        prev_size = jobs.size
+        jobs.select{|j| j.new? }.each do |job|
+          if store.available_stock(job.resource) >= 1
+            job.allocate(store.allocate(job.resource, 1))
+          else
+            job.resource.dependent_resources.each do |dr|
+              job.resource.dependent_resource_amount(dr).times do
+                djob = Job.new(dr)
+                job.add_dependent(djob)
+                jobs << djob
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def next
+      puts "determine the next action"
+      # any project finished?
+      action = project_ready
+      return action if action
+      # any pure request?
+      action = something_dependent_to_produce
+      return action if action
+      # anything to pickup?
+      action = something_to_pick
+      return action if action
+      # anything that can be produced?
+      action = something_pure_to_produce
+      if action
+        return action
+      else
+        return "wait"
+      end
+    end
+
+    def project_ready
+      puts " -> is there a project ready for delivery?"
+      @projects.keys.each do |project|
+        ready = true
+        @projects[project].each do |job|
+          unless job.allocated?
+            ready = false
+            break
+          end
+        end
+
+        if ready
+          finish_project(project)
+          # we are done and the project can be finished.
+          return "finish #{project.name}"
+        end
+      end
+      nil
+    end
+
+    def finish_project(project)
+      # get all the allocated resources
+      @projects[project].each do |job|
+        job.allocation.get
+      end
+      # remove the project from scheduling
+      @projects.delete(project)
+    end
+
+    def something_pure_to_produce
+      puts " -> is there something without dependencies to produce?"
+      @projects.keys.each do |project|
+        @projects[project].each do |job|
+          if job.new?
+            factory = @configuration.factory_for(job.resource)
+            if factory.free_capacity > 0
+              job.produce(factory.produce(job.resource))
+              return "produce #{job.resource.name}"
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    def something_to_pick
+      puts " -> is there something to pick?"
+      @projects.keys.each do |project|
+        @projects[project].each do |job|
+          if job.ready? && store.free_capacity > 0
+            @configuration.factory_for(job.resource).pick(job.production)
+            store.put(job.resource, 1)
+            job.allocate(store.allocate(job.resource, 1))
+            return "pick #{job.resource.name}"
+          end
+        end
+      end
+      nil
+    end
+
+    def something_dependent_to_produce
+      puts " -> is there something with dependencies ready for production?"
+      @projects.keys.each do |project|
+        @projects[project].each do |job|
+          if job.allocated_dependencies?
+
+            # extract the requirements
+            requirements = job.dependent_jobs.map{|j| j.allocation }
+            # produce the resource
+
+            factory = @configuration.factory_for(job.resource)
+
+            if factory.free_capacity > 0
+              puts "go for a complex production: #{job.resource}"
+              job.produce(factory.produce(job.resource, requirements))
+
+              # remove the dependent jobs
+              job.dependent_jobs.each{|j| @projects[project].delete(j)}
+              # reset the job dependency
+              job.reset_dependent_jobs
+
+              return "produce #{job.resource.name}"
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    # debugging
+    def print_job_lists
+      @projects.keys.each do |project|
+        puts
+        puts "Project: #{project.name}"
+        puts ""
+        @projects[project].each_with_index do |job, idx|
+          puts "\t Step-#{idx} - #{job_line(job)}"
+        end
+        puts
+      end
+    end
+
+    def job_line(job)
+      "#{job.resource.name}: allocation: #{job.allocation} production: #{job.production} dependent: #{job.dependent_jobs.map{|j| j.resource.name}} new: #{job.new?} ready: #{job.ready?} allocated dependencies: #{job.allocated_dependencies?}"
+    end
+    # debugging
+
+    def load_project(project, job_list)
+      @projects[project] = job_list
+    end
+
+    def to_hash
+      {
+        projects: @projects.keys.map{|p| project_hash(p, @projects[p])}
+      }
+    end
+
+    def project_hash(project, job_list)
+      {
+        "name" => project.name,
+        "requirements" => project.resources.map{|r| {"resource" => r.name, "amount" => project.amount(r)}},
+        "jobs" => job_list.map{|j| j.to_hash}
+      }
+    end
+
+    private
+
+    def store
+      @configuration.store
+    end
+
+  end
+end

data/lib/smcty/store.rb

@@ -0,0 +1,115 @@
+require 'smcty/allocation'
+require 'set'
+
+module Smcty
+  class Store
+    attr_reader :name, :capacity
+
+    def initialize(name, capacity)
+      @name = name
+      @capacity = capacity
+      @storage = {}
+      @allocations = Set.new
+    end
+
+    def free_capacity
+      @capacity - total_available_stock - total_allocated_stock
+    end
+
+    def total_available_stock
+      result = 0
+      @storage.values.each do |value|
+        result += value
+      end
+      result
+    end
+
+    def total_allocated_stock
+      result = 0
+      @allocations.each do |alloc|
+        result += alloc.amount
+      end
+      result
+    end
+
+    def available_stock(resource)
+      @storage[resource] || 0
+    end
+
+    def allocated_stock(resource)
+      result = 0
+      @allocations.each do |alloc|
+        result += alloc.amount if resource == alloc.resource
+      end
+      result
+    end
+
+    def total_stock(resource)
+      available_stock(resource) + allocated_stock(resource)
+    end
+
+    def put(resource, _amount=1)
+      # at least one item of the resource
+      amount = [1, _amount].max
+
+      unless free_capacity >= amount
+        raise "The store is full - Cannot put #{amount} items of #{resource.name}"
+      end
+
+      in_stock = available_stock(resource)
+      @storage[resource] = in_stock + amount
+      amount
+    end
+
+    def allocate(resource, _amount)
+      # at least one item of the resource
+      amount = [1, _amount].max
+
+      in_stock = available_stock(resource)
+      unless in_stock >= amount
+        raise "#{in_stock} is not enough of #{resource.name} to allocate #{amount} items"
+      end
+
+      @storage[resource] = in_stock - amount
+      allocation = Allocation.new(self, resource, amount)
+      @allocations.add(allocation)
+      allocation
+    end
+
+    def get(allocation)
+      @allocations.delete(allocation)
+    end
+
+    def free(allocation)
+      put(allocation.resource, allocation.amount)
+      @allocations.delete(allocation)
+    end
+
+    def valid?(allocation)
+      @allocations.include?(allocation)
+    end
+
+    def inventory
+      @storage.keys
+    end
+
+    def to_s
+      "Store #{@name} has a total capacity of #{@capacity} whereas the free capacity is #{free_capacity}"
+    end
+
+    def to_hash
+      {
+        "name" => @name,
+        "capacity" => @capacity,
+        "stock" => @storage.keys.map{|k| {"name" => k.name, "amount" => total_stock(k)}}
+      }
+    end
+
+    private
+
+    def enforce(lower, amount, upper)
+      [[lower, amount].max, upper].min
+    end
+
+  end
+end

data/lib/smcty/version.rb

@@ -0,0 +1,3 @@
+module Smcty
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: smcty
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Markus Kuhnt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-25 00:00:00.000000000 Z
+dependencies: []
+description: Plan your production based on scheduled plans to optimize throughput.
+email:
+- markus.kuhnt@gmail.com
+executables:
+- smcty
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/smcty
+- lib/smcty.rb
+- lib/smcty/allocation.rb
+- lib/smcty/configuration.rb
+- lib/smcty/configurator.rb
+- lib/smcty/console.rb
+- lib/smcty/factory.rb
+- lib/smcty/helpers.rb
+- lib/smcty/job.rb
+- lib/smcty/output.rb
+- lib/smcty/planner.rb
+- lib/smcty/production.rb
+- lib/smcty/project.rb
+- lib/smcty/resource.rb
+- lib/smcty/scheduling.rb
+- lib/smcty/store.rb
+- lib/smcty/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: A production planning software for simcity(tm)
+test_files: []