rollio 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bef6820ce929c27df6d2f18caed085a06e490809a720f95dcb19621724ce4b4b
-  data.tar.gz: 5be947c8d951a0b3d9a3e586dfad03a14a49980c5c5da9b6e582dbcdd57bf07b
+  metadata.gz: e6d9919949718ff310a8dfdc0100df7c723b65674f43434e750412c52383b265
+  data.tar.gz: 7fd4483fd44dec675c22ace6269e1e4e95313c81ad4b84d8f0508cad7b8eb2fe
 SHA512:
-  metadata.gz: e3e0f3f3b297919c07de06ec1be9610a4ecf2a994f94902002c5f6091a2ecd81b9996acba4e10f521d89d14a8dd5f8a6780a9391f7c1914dd370c1af49ddc245
-  data.tar.gz: d200112f6ac80c0aed9306f6c56d53280dc341fa8e31ac597e99f58e15f1b4e95526579a918b9d91d5c24b4fefeeeb3f69be2dbf01e684a570bc16ccdc209d13
+  metadata.gz: 37ee8ea172926651aa22d54479b369752685278544ca5a93a8425361ba6e98ae63daad182485e0a789058638394b3998a6bd68eaf254072b358aed0966c1c7dc
+  data.tar.gz: 6c31a6c62645d7bfc6d93f8774ef5a864ae221e0d077fb37243e9105d561b16921040dbd64189233c502b6aa4a2a28ec92d44fdd88aae2b695405ec2bf957fff

data/Gemfile

@@ -4,3 +4,5 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in rollio.gemspec
 gemspec
+
+gem 'byebug'

data/README.md

@@ -4,14 +4,16 @@ A tool for loading random tables, rolling on those tables, and rendering the out
 
 ## Todo List
 
-- [ ] Create schema to define valid JSON document
+- [X] Create schema to define valid JSON document
 - [ ] Integrate schema validation for loaded JSON document
-- [ ] Allow inner-table logic\*
-- [ ] Create structure for loading tables
+- [X] Allow inner-table logic\*
+- [X] Create structure for loading tables
 - [ ] Create command line tool
-  - [ ] List available tables (with help) (e.g. `rollio roll -h`)
-  - [ ] Look to parameterization of table rolls
-  - [ ] Roll on tables (e.g. `rollio roll background`)
+- [X] List available tables (with help) (e.g. `rollio roll -h`)
+- [ ] Look to parameterization of table rolls
+- [X] Roll on tables (e.g. `rollio roll background`)
+- [ ] Create structure for SWN batch of tables to roll at once
+- [ ] Add ability to roll a dice expression via `rollio roll`
 
 \* - By inner table logic I'm referring to "On a d10 table, when you roll a 9 or 10, roll on this table twice using a d8"
 

data/data/defy_danger.json

@@ -0,0 +1,10 @@
+{
+  "key": "defy_danger",
+  "label": "Defy Danger",
+  "roll": "2d6",
+  "entries": [
+    { "range": [-1,0,1,2,3,4,5,6], "result": "You do it"},
+    { "range": [7,8,9], "result": "You stumble, hesitate, or flinch: the GM will offer you a worse outcome, hard bargain, or ugly choice." },
+    { "range": [10,11,12,13,14,15,16], "result": "You flounder: the GM will make a hard move"}
+  ]
+}

data/data/examples.json

@@ -0,0 +1,24 @@
+[{
+ "key": "table-a",
+ "roll": "2d6",
+ "entries": [
+   { "range": [2,3,4,5,6], "roll_on": "table-b", "with": "1d3", "times": 2},
+   { "range": [7], "result": "Yolo" },
+   { "range": [8,9,10,11,12], "inner_table": {
+       "roll": "1d4",
+       "entries": [
+         { "range": [1,2,3], "result": "Yes" },
+         { "range": [4], "result": "No" }
+       ]
+     }
+   }
+ ]},{
+   "key": "table-b",
+   "roll": "1d6",
+   "entries": [
+     { "range": [1], "result": "least result from sub-table" },
+     { "range": [2,3,4,5], "result": "mid-range result from sub-table" },
+     { "range": [6], "result": "greatest result from sub-table" }
+   ]
+ }
+]

data/exe/rollio

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rollio/cli'
+
+Rollio::CLI.start(ARGV)

data/lib/rollio.rb

@@ -1,6 +1,75 @@
 require "rollio/version"
 require "rollio/registry"
+require 'json'
+require 'hanami/utils/hash'
 
 module Rollio
-  # Your code goes here...
+  # @api private
+  # @example
+  # document = [{
+  #   key: '1-a',
+  #   roll: '2d6',
+  #   entries: [
+  #     { range: [2,3,4,5,6], roll_on: '1-b', with: '1d3', times: 2},
+  #     { range: [7], result: 'Yolo' },
+  #     { range: [8,9,10,11,12], inner_table: {
+  #         roll: '1d4',
+  #         entries: [
+  #           { range: [1,2,3], result: 'Yes' },
+  #           { range: [4], result: 'No' }
+  #         ]
+  #       }
+  #     }
+  #   },{
+  #     key: '1-b',
+  #     roll: '1d6',
+  #     entries: [
+  #       { range: [1,2,3,4,5,6], result: 'sub-table' }
+  #     ]
+  #   }
+  # ]
+  # registry = Rollio::Registry.load(document)
+  #
+  # @example
+  #   registry = Rollio::Registry.load do
+  #     table('1') do
+  #       roll('1d5')
+  #       entry(1, 'Yes!')
+  #       entry(2..5, 'No!')
+  #     end
+  #   end
+  # @return [Rollio::Registry, #roll_on]
+  # @todo Add document schema and validation
+  def self.load(document = nil, context = self, &block)
+    if document
+      Registry.new do |registry|
+        document.each do |data|
+          context.load_a_table(registry: registry, data: data, context: context)
+        end
+      end
+    else
+      Registry.new(&block)
+    end
+  end
+
+  # @api private
+  # @todo Does the guts of this logic make sense here?
+  def self.load_a_table(registry: , data:, context: self, key: nil)
+    key ||= data.fetch(:key)
+    label = data.fetch(:label, key)
+    table = registry.table(key, label: label)
+    table.roll(data.fetch(:roll))
+    data.fetch(:entries).each do |table_entry|
+      range = table_entry.fetch(:range)
+      if table_entry.key?(:roll_on)
+        table.entry(range, **table_entry)
+      elsif table_entry.key?(:result)
+        table.entry(range, table_entry.fetch(:result))
+      elsif table_entry.key?(:inner_table)
+        inner_table = table_entry.fetch(:inner_table)
+        entry = table.entry(range, inner_table: true)
+        context.load_a_table(registry: registry, data: inner_table, context: context, key: entry.key)
+      end
+    end
+  end
 end

data/lib/rollio/cli.rb

@@ -0,0 +1,65 @@
+require 'thor'
+require 'rollio'
+module Rollio
+  class CLI < Thor
+    option(
+      :source,
+      aliases: '-s',
+      required: true,
+      default: File.join(ENV['HOME'], '.rollio'),
+      desc: "The <source> directory for tables to load into rollio"
+    )
+    def initialize(*args)
+      super
+      register!
+    end
+
+    desc "list", "List the registered tables"
+    long_desc <<-LONGDESC
+      `rollio list` will print out a list of all registered tables
+    LONGDESC
+    option(
+      :delimiter,
+      aliases: '-d',
+      desc: "The <delimiter> used to separate the table entries"
+    )
+    option(:help, aliases: '-h')
+    def list
+      help(__method__) and return if options[:help]
+      $stdout.puts @registry.table_names.join(options.fetch(:delimiter, "\n"))
+    end
+
+    desc "audit", "Audit the tables in <source> to ensure validity"
+    option(:help, aliases: '-h')
+    def audit
+    end
+
+    desc "roll <table>", "Roll on the given table"
+    option(:help, aliases: '-h')
+    def roll(table)
+      help(__method__) and return if options[:help]
+      $stdout.puts @registry.roll_on(table)
+    end
+
+    desc "render", "Render the stored tables"
+    option(:help, aliases: '-h')
+    def render
+      help(__method__) and return if options[:help]
+      $stdout.puts @registry.render
+    end
+
+    private
+
+    def register!
+      @registry = Rollio.load
+      Dir.glob("#{options[:source]}/**/*.json").each do |filename|
+        tables = JSON.parse(File.read(filename))
+        tables = [tables] unless tables.is_a?(Array)
+        tables.each do |table|
+          data = Hanami::Utils::Hash.deep_symbolize(table)
+          Rollio.load_a_table(registry: @registry, data: data)
+        end
+      end
+    end
+  end
+end

data/lib/rollio/range.rb

@@ -0,0 +1,121 @@
+module Rollio
+  module Range
+    def self.new(table:, range:, result:, roll_on: nil, inner_table: nil, inner_table_config: nil, times: 1, with: nil)
+      if result
+        Result.new(table: table, range: range, result: result, times: times)
+      elsif roll_on
+        RollOn.new(table: table, range: range, roll_on: roll_on, times: times, with: with)
+      elsif inner_table
+        InnerRollOn.new(table: table, range: range, times: times)
+      elsif inner_table_config
+        InnerTable.new(table: table, range: range, inner_table: inner_table_config, times: times)
+      else
+        raise "Hello"
+      end
+    end
+
+    class Base
+      attr_reader :table, :range, :times
+      def initialize(table:, range:, times:, **kwargs)
+        @table = table
+        self.range = range
+        @times = times
+      end
+
+      def key
+        "#{table.key} (Sub #{range})"
+      end
+
+      extend Comparable
+      def <=>(other)
+        range.first <=> other.range.first
+      end
+
+      def render
+        if range.first == range.last
+          puts "#{range.first}\t#{result}"
+        else
+          puts "#{range.first}-#{range.last}\t#{result}"
+        end
+      end
+
+      def result
+        raise NotImplementedError
+      end
+
+      extend Forwardable
+      def_delegator :table, :table_set
+
+      def include?(value)
+        if @range.respond_to?(:include?)
+          @range.include?(value)
+        else
+          @range == value
+        end
+      end
+
+      def range=(input)
+        @range = Array(input)
+      end
+    end
+    private_constant :Base
+
+    class Result < Base
+      attr_reader :result
+      def initialize(result:, **kwargs)
+        super(**kwargs)
+        @result = result
+      end
+
+      def roll!
+        [@result]
+      end
+    end
+    private_constant :Result
+
+    class RollOn < Base
+      attr_reader :with
+      def initialize(roll_on:, **kwargs)
+        super(**kwargs)
+        @roll_on = roll_on
+        @with = kwargs[:with]
+      end
+
+      def roll!
+        (1..times).map { table_set.roll_on(@roll_on, with: with) }
+      end
+
+      def result
+        "Roll on #{@roll_on}"
+      end
+    end
+    private_constant :RollOn
+
+    class InnerRollOn < Base
+      def roll!
+        (1..times).map { table_set.roll_on(key) }
+      end
+
+      def result
+        "Roll on #{key}"
+      end
+    end
+
+    class InnerTable < Base
+      def initialize(inner_table:, **kwargs)
+        super(**kwargs)
+        @table.table_set.add(key, &inner_table)
+      end
+
+      def roll!
+        (1..times).map { table_set.roll_on(key) }
+      end
+
+      def result
+        "Roll on #{key}"
+      end
+    end
+    private_constant :InnerTable
+  end
+  private_constant :Range
+end

data/lib/rollio/range_set.rb

@@ -0,0 +1,26 @@
+require 'rollio/range'
+module Rollio
+  class RangeSet
+    def initialize(table:)
+      @table = table
+      @ranges = []
+    end
+
+    def render
+      @ranges.sort.each do |range|
+        range.render
+      end
+    end
+
+    def resolve(roll:)
+      @ranges.detect { |range| range.include?(roll) }.roll!
+    end
+
+    def add(range:, **kwargs)
+      range_object = Range.new(range: range, **kwargs)
+      @ranges << range_object
+      range_object
+    end
+  end
+  private_constant :RangeSet
+end

data/lib/rollio/registry.rb

@@ -1,332 +1,36 @@
 require 'forwardable'
 require 'dice' # from dice_parser
+require 'rollio/table_set'
 
 module Rollio
   # Responsible for registering random tables and exposing a means of rolling on those tables.
   class Registry
-    # @api private
-    # @example
-    # document = [{
-    #   key: '1-a',
-    #   roll: '2d6',
-    #   entries: [
-    #     { range: [2,3,4,5,6], roll_on: '1-b'},
-    #     { range: [7], result: 'Yolo' },
-    #     { range: [8,9,10,11,12], inner_table: {
-    #         roll: '1d4',
-    #         entries: [
-    #           { range: [1,2,3], result: 'Yes' },
-    #           { range: [4], result: 'No' }
-    #         ]
-    #       }
-    #     }
-    #   },{
-    #     key: '1-b',
-    #     roll: '1d6',
-    #     entries: [
-    #       { range: [1,2,3,4,5,6], result: 'sub-table' }
-    #     ]
-    #   }
-    # ]
-    # registry = Rollio::Registry.load(document)
-    #
-    # @example
-    #   registry = Rollio::Registry.load do
-    #     table('1') do
-    #       roll('1d5')
-    #       entry(1, 'Yes!')
-    #       entry(2..5, 'No!')
-    #     end
-    #   end
-    # @return [Rollio::Registry, #roll_on]
-    # @todo Add document schema and validation
-    # @todo Expose #load method to allow additional loading outside of initialization
-    def self.load(document = nil, context = self, &block)
-      if document
-        Registry.new do |registry|
-          document.each do |data|
-            context.load_a_table(registry: registry, data: data, context: context)
-          end
-        end
-      else
-        Registry.new(&block)
-      end
-    end
-
-    # @api private
-    def self.load_a_table(registry:, data:, context:, key: nil)
-      key ||= data.fetch(:key)
-      label = data.fetch(:label, key)
-      table = registry.table(key, label: label)
-      table.roll(data.fetch(:roll))
-      data.fetch(:entries).each do |table_entry|
-        range = table_entry.fetch(:range)
-        if table_entry.key?(:roll_on)
-          table.entry(range, roll_on: table_entry.fetch(:roll_on), times: table_entry.fetch(:times, 1))
-        elsif table_entry.key?(:result)
-          table.entry(range, table_entry.fetch(:result))
-        elsif table_entry.key?(:inner_table)
-          inner_table = table_entry.fetch(:inner_table)
-          entry = table.entry(range, inner_table: true)
-          Registry.load_a_table(registry: registry, data: inner_table, context: context, key: entry.key)
-        end
-      end
-    end
-
-    attr_reader :table_set
+    # @api public
     def initialize(&block)
-      @table_set = TableSet.new(registry: self)
+      self.table_set = TableSet.new(registry: self)
       instance_exec(self, &block) if block_given?
     end
 
+    attr_accessor :table_set
+    private :table_set=
+
     # @api private
     # @param key [String] The key of the table you want to roll on
     # @see Registry::Table#key for details
     # @todo Consider adding a modifier (eg. `roll_on(key, with: -2)`)
-    def roll_on(key)
-      @table_set.roll_on(key)
+    def roll_on(key, **kwargs)
+      table_set.roll_on(key, **kwargs)
     end
 
+    # @api private
+    # The exposed method for adding a table to the registry
     def table(*args, &block)
-      @table_set.add(*args, &block)
+      table_set.add(*args, &block)
     end
 
     extend Forwardable
     def_delegator :table_set, :render
-
-    class TableSet
-      extend Forwardable
-
-      def initialize(registry:)
-        @registry = registry
-        @tables = {}
-      end
-
-      private
-
-      attr_reader :tables, :registry
-
-      public
-
-      def roll_on(table_name)
-        table = @tables.fetch(table_name)
-        table.roll!
-      end
-
-      def add(key, label: key, &block)
-        @tables[key] = Table.new(table_set: self, key: key, label: label, &block)
-      end
-
-      def render(debug: false)
-        puts "Table Set { object_id: #{object_id} }\n" if debug
-        @tables.sort { |a,b| a[0] <=> b[0] }.each do |key, table|
-          table.render
-        end
-        nil
-      end
-    end
-    private_constant :TableSet
-
-    class Table
-      attr_reader :key, :table_set, :label, :roller
-      private :roller
-      def initialize(table_set:, key:, label:, &block)
-        @key = key
-        @table_set = table_set
-        @label = label
-        @range_set = RangeSet.new(table: self)
-        instance_exec(self, &block)  if block_given?
-      end
-
-      def render
-        header = "Table: #{key}"
-        header = "#{header} - #{label}" unless label == key
-        puts header
-        puts '-' * header.length
-        roller.render
-        @range_set.render
-      end
-
-      def roll!(the_roller: roller)
-        roll = the_roller.roll!
-        @range_set.resolve(roll: roll)
-      end
-
-      def roll(text)
-        @roller = Roller.new(text)
-      end
-
-      def entry(range, result = nil, roll_on: nil, inner_table: nil, times: 1, &inner_table_config)
-        @range_set.add(
-          table: self,
-          range: range,
-          result: result,
-          roll_on: roll_on,
-          inner_table: inner_table,
-          inner_table_config: inner_table_config,
-          times: times
-        )
-      end
-
-      protected
-
-        class Roller
-          def initialize(text)
-            @text = text
-          end
-
-          def roll!
-            Dice.roll(@text)
-          end
-
-          def render
-            puts "#{@text}\tResult"
-          end
-        end
-        private_constant :Roller
-
-      class RangeSet
-        def initialize(table:)
-          @table = table
-          @ranges = []
-        end
-
-        def render
-          @ranges.sort.each do |range|
-            range.render
-          end
-        end
-
-        def resolve(roll:)
-          @ranges.detect { |range| range.include?(roll) }.roll!
-        end
-
-        def add(range:, **kwargs)
-          range_object = Range.new(range: range, **kwargs)
-          @ranges << range_object
-          range_object
-        end
-      end
-      private_constant :RangeSet
-
-      module Range
-        def self.new(table:, range:, result:, roll_on:, inner_table:, inner_table_config:, times:)
-          if result
-            Result.new(table: table, range: range, result: result, times: times)
-          elsif roll_on
-            RollOn.new(table: table, range: range, roll_on: roll_on, times: times)
-          elsif inner_table
-            InnerRollOn.new(table: table, range: range, times: times)
-          elsif inner_table_config
-            InnerTable.new(table: table, range: range, inner_table: inner_table_config, times: times)
-          else
-            raise "Hello"
-          end
-        end
-
-        class Base
-          attr_reader :table, :range, :times
-          def initialize(table:, range:, times:)
-            @table = table
-            self.range = range
-            @times = times
-          end
-
-          def key
-            "#{table.key} (Sub #{range})"
-          end
-
-          extend Comparable
-          def <=>(other)
-            range.first <=> other.range.first
-          end
-
-          def render
-            if range.first == range.last
-              puts "#{range.first}\t#{result}"
-            else
-              puts "#{range.first}-#{range.last}\t#{result}"
-            end
-          end
-
-          def result
-            raise NotImplementedError
-          end
-
-          extend Forwardable
-          def_delegator :table, :table_set
-
-          def include?(value)
-            if @range.respond_to?(:include?)
-              @range.include?(value)
-            else
-              @range == value
-            end
-          end
-
-          def range=(input)
-            @range = Array(input)
-          end
-        end
-        private_constant :Base
-
-        class Result < Base
-          attr_reader :result
-          def initialize(result:, **kwargs)
-            super(**kwargs)
-            @result = result
-          end
-
-          def roll!
-            [@result]
-          end
-        end
-        private_constant :Result
-
-        class RollOn < Base
-          def initialize(roll_on:, **kwargs)
-            super(**kwargs)
-            @roll_on = roll_on
-          end
-
-          def roll!
-            (1..times).map { table_set.roll_on(@roll_on) }
-          end
-
-          def result
-            "Roll on #{@roll_on}"
-          end
-        end
-        private_constant :RollOn
-
-        class InnerRollOn < Base
-          def roll!
-            (1..times).map { table_set.roll_on(key) }
-          end
-
-          def result
-            "Roll on #{key}"
-          end
-        end
-
-        class InnerTable < Base
-          def initialize(inner_table:, **kwargs)
-            super(**kwargs)
-            @table.table_set.add(key, &inner_table)
-          end
-
-          def roll!
-            (1..times).map { table_set.roll_on(key) }
-          end
-
-          def result
-            "Roll on #{key}"
-          end
-        end
-        private_constant :InnerTable
-      end
-      private_constant :Range
-    end
-    private_constant :Table
+    def_delegator :table_set, :table_names
   end
+  private_constant :Registry
 end

data/lib/rollio/roller.rb

@@ -0,0 +1,18 @@
+require 'dice' # from dice_parser
+
+module Rollio
+  class Roller
+    def initialize(text)
+      @text = text
+    end
+
+    def roll!
+      Dice.roll(@text)
+    end
+
+    def render
+      puts "#{@text}\tResult"
+    end
+  end
+  private_constant :Roller
+end

data/lib/rollio/schemas/entry_schema.rb

@@ -0,0 +1,24 @@
+require 'dry-validation'
+module Rollio
+  module Schemas
+    EntrySchema = Dry::Validation.Schema do
+      required(:range).each(:int?)
+      optional(:result).maybe(:str?)
+      optional(:roll_on).maybe(:str?)
+      optional(:inner_table).schema do
+        required(:roll).filled(:str?)
+        required(:entries).each do
+          schema do
+            required(:range).each(:int?)
+            optional(:result).maybe(:str?)
+            optional(:roll_on).maybe(:str?)
+          end
+        end
+      end
+
+      rule :result_or_inner_table_or_rolled_on_is_required do
+        value(:result).filled? ^ value(:roll_on).filled? ^ value(:inner_table).filled?
+      end
+    end
+  end
+end

data/lib/rollio/schemas/table_schema.rb

@@ -0,0 +1,13 @@
+require 'dry-validation'
+require 'rollio/schemas/entry_schema'
+module Rollio
+  module Schemas
+    TableSchema = Dry::Validation.Schema do
+      required(:key).filled(:str?)
+      required(:roll).filled(:str?)
+      required(:entries).each do
+        schema(EntrySchema)
+      end
+    end
+  end
+end

data/lib/rollio/table.rb

@@ -0,0 +1,45 @@
+require 'rollio/roller'
+require 'rollio/range_set'
+module Rollio
+  class Table
+    attr_reader :key, :table_set, :label, :roller
+    private :roller
+    def initialize(table_set:, key:, label:, &block)
+      @key = key
+      @table_set = table_set
+      @label = label
+      @range_set = RangeSet.new(table: self)
+      instance_exec(self, &block)  if block_given?
+    end
+
+    def render
+      header = "Table: #{key}"
+      header = "#{header} - #{label}" unless label == key
+      puts header
+      puts '-' * header.length
+      roller.render
+      @range_set.render
+    end
+
+    def roll!(with: roller)
+      the_roller = with.is_a?(Roller) ? with : Roller.new(with)
+      roll = the_roller.roll!
+      @range_set.resolve(roll: roll)
+    end
+
+    def roll(text)
+      @roller = Roller.new(text)
+    end
+
+    def entry(range, result = nil, **kwargs, &inner_table_config)
+      @range_set.add(
+        table: self,
+        range: range,
+        result: result,
+        inner_table_config: inner_table_config,
+        **kwargs
+      )
+    end
+  end
+  private_constant :Table
+end

data/lib/rollio/table_set.rb

@@ -0,0 +1,40 @@
+require 'rollio/table'
+
+module Rollio
+  # The data store for all of the registered tables
+  class TableSet
+
+    def initialize(registry:)
+      @registry = registry
+      @tables = {}
+    end
+
+    private
+
+    attr_reader :tables, :registry
+
+    public
+
+    def table_names
+      tables.keys.sort
+    end
+
+    def roll_on(table_name, **kwargs)
+      table = tables.fetch(table_name)
+      table.roll!(**kwargs)
+    end
+
+    def add(key, label: key, &block)
+      tables[key] = Table.new(table_set: self, key: key, label: label, &block)
+    end
+
+    def render(debug: false)
+      puts "Table Set { object_id: #{object_id} }\n" if debug
+      tables.sort { |a,b| a[0] <=> b[0] }.each do |key, table|
+        table.render
+      end
+      nil
+    end
+  end
+  private_constant :TableSet
+end

data/lib/rollio/version.rb

@@ -1,3 +1,3 @@
 module Rollio
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/rollio.gemspec

@@ -27,4 +27,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_dependency "dice_parser"
+  spec.add_dependency "dry-validation"
+  spec.add_dependency "json"
+  spec.add_dependency "hanami-utils"
+  spec.add_dependency "thor"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollio
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Jeremy Friesen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-03 00:00:00.000000000 Z
+date: 2018-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,10 +66,67 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hanami-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A DSL and JSON Schema for RPG tables
 email:
 - jeremy.n.friesen@gmail.com
-executables: []
+executables:
+- rollio
 extensions: []
 extra_rdoc_files: []
 files:
@@ -83,8 +140,19 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- data/defy_danger.json
+- data/examples.json
+- exe/rollio
 - lib/rollio.rb
+- lib/rollio/cli.rb
+- lib/rollio/range.rb
+- lib/rollio/range_set.rb
 - lib/rollio/registry.rb
+- lib/rollio/roller.rb
+- lib/rollio/schemas/entry_schema.rb
+- lib/rollio/schemas/table_schema.rb
+- lib/rollio/table.rb
+- lib/rollio/table_set.rb
 - lib/rollio/version.rb
 - rollio.gemspec
 homepage: https://github.com/jeremyf/rollio