batali 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc4ffb55cfc9404110a31d84080917bd03fe57c5
-  data.tar.gz: a90b9dbf07e2aeb1aa793ab3ae1bc747ecd320fb
+  metadata.gz: 12ae5060ad51ee573081c34f077e1242908dddd7
+  data.tar.gz: b569cf195a11b93a1b7c1ddf87df063c63df1693
 SHA512:
-  metadata.gz: 3289b9038b99b8d76f8ad18f30a7c3faa472d6586979b6a861d60f10119d2c9ce6bc38059c3cd9f6bea929bdf3bc06b8e156e0be44dfe0a4fe4a90011fb17c4c
-  data.tar.gz: a6aaa1cb5819cac5d4c26840e200e379398f0da606a6f7198947158ac2855ad6e45784594a211cb4c3a7cbe6a521c7aa5bb9bc2a98e26f6238f98658f4742f11
+  metadata.gz: 909cfbcd842a0f2187efab1e4bf9453bc15234e38a0de13317b6ae1a5cf02b222cf499b4caf8ef6da814aa12c1cb74f2dbbde92089645ac9410e230f63f0d1e5
+  data.tar.gz: 1523d71a2af4dd85a487effeeb1bc967160f1093fec75925019afee3f3b128d0e32f3d07d983740d08f754e3732838ba909d672d2c565456466fbc660a333642

data/CHANGELOG.md

@@ -1,2 +1,2 @@
 # v0.1.0
-* Initial commit
+* Initial release

data/README.md

@@ -1,5 +1,36 @@
 # Batali
 
-## Info
+Batali is a light weight cookbook resolver. It is currently
+in an alpha state and should not be used with anything you
+care about or love. There is a high chance it will burn it
+all to the ground, and laugh.
+
+## Usage
+
+Provide a `Batali` file:
+
+```ruby
+Batali.define do
+  source 'https://supermarket.chef.io'
+  cookbook 'postgresql'
+end
+```
+
+and then run:
+
+```
+$ batali update
+```
+
+in the same directory. It will destroy your `cookbooks` directory
+by default.
+
+_IT WILL DESTROY YOUR COOKBOOKS DIRECTORY BY DEFAULT_
+
+There is other cool stuff too, to be documented later. Currently
+only site sources can be defined (no path, or git, or anything else).
+
+
+# Info
 
 * Repository: https://github.com/hw-labs/batali

data/batali.gemspec

@@ -10,7 +10,13 @@ Gem::Specification.new do |s|
   s.description = 'Magic'
   s.require_path = 'lib'
   s.license = 'Apache 2.0'
+  s.add_runtime_dependency 'grimoire', '>= 0.1.2'
+  s.add_runtime_dependency 'bogo', '>= 0.1.12'
+  s.add_runtime_dependency 'bogo-cli', '>= 0.1.8'
+  s.add_runtime_dependency 'bogo-config', '>= 0.1.10'
+  s.add_runtime_dependency 'http'
   s.add_development_dependency 'minitest'
   s.add_development_dependency 'pry'
+  s.executables << 'batali'
   s.files = Dir['{lib,bin}/**/**/*'] + %w(batali.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)
 end

data/bin/batali

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'batali'
+
+Bogo::Cli::Setup.define do
+
+  on :v, :version, 'Print version' do
+    puts "batali - Cookbook Collection Manager - [Version: #{Batali::VERSION}]"
+    exit
+  end
+
+  global_opts = lambda do
+    on :c, :config, 'Configuration file path'
+    on :V, :verbose, 'Enable verbose output'
+    on :D, :debug, 'Enable debug mode'
+    on :f, :file, 'Path to Batali file'
+  end
+
+  command 'install' do
+    description 'Install cookbooks from manifest'
+    self.instance_exec(&global_opts)
+    on :d, 'dry-run', 'Print changes'
+    on :p, 'path', 'Cookbook install path'
+    run do |opts, args|
+      Batali::Command::Install.new({:install => opts.to_hash}, args).execute!
+    end
+  end
+
+  command 'update' do
+    description 'Update cookbooks manifest'
+    self.instance_exec(&global_opts)
+    on :d, 'dry-run', 'Print changes'
+    on :l, 'least-impact', 'Update cookbooks with minimal version impact', :default => true
+    on :i, 'install', 'Install cookbooks after update', :default => true
+
+    run do |opts, args|
+      Batali::Command::Update.new({:update => opts.to_hash}, args).execute!
+    end
+  end
+
+  command 'resolve' do
+    description 'Build the cookbook manifest'
+    self.instance_exec(&global_opts)
+    on :d, 'dry-run', 'Print changes'
+    on :l, 'least-impact', 'Update cookbooks with minimal version impact', :default => true
+
+    run do |opts, args|
+      Batali::Command::Resolve.new({:resolve => opts.to_hash}, args).execute!
+    end
+  end
+
+  command 'configure' do
+    self.instance_exec(&global_opts)
+    run do |opts, args|
+      Batali::Command::Configure.new(opts, args).execute!
+    end
+  end
+
+end

data/lib/batali/b_file.rb

@@ -0,0 +1,61 @@
+require 'batali'
+
+module Batali
+
+  class Struct < AttributeStruct
+
+    def cookbook(*args)
+      set!(:cookbook, args)
+      self
+    end
+
+  end
+
+  # Create a new file
+  #
+  # @param block [Proc]
+  # @return [AttributeStruct]
+  def self.define(&block)
+    struct = Struct.new
+    struct.set_state!(:value_collapse => true)
+    struct.build!(&block)
+    struct
+  end
+
+  class BFile < Bogo::Config
+
+    class Cookbook < Grimoire::Utility
+      attribute :name, String, :required => true
+      attribute :constraint, String, :multiple => true
+      attribute :git, Smash, :coerce => lambda{|v| v.to_smash}
+      attribute :path, String
+    end
+
+    attribute :source, RemoteSite, :multiple => true, :coerce => lambda{|v| RemoteSite.new(:endpoint => v)}
+    attribute :cookbook, Cookbook, :multiple => true, :coerce => lambda{|v|
+      case v
+      when Array
+        Cookbook.new(
+          :name => v.first,
+          :constraint => v.slice(1, v.size)
+        )
+      when String
+        Cookbook.new(:name => v)
+      when Hash
+        c_name = v.keys.first
+        constraints = v.values.first.to_a.flatten.find_all{|i| i.is_a?(String)}
+        Cookbook.new(
+          :name => c_name,
+          :constraint => constraints
+        )
+      else
+        raise ArgumentError.new "Unable to coerce given type `#{v.class}` to `Batali::BFile::Cookbook`!"
+      end
+    }
+
+    ## TODO: supported values still required
+    # attribute :restrict -- restrict cookbooks of name `x` to source  named `y`
+    # attribute :group -- cookbook grouping (i.e. :integration)
+  end
+
+end

data/lib/batali/command/configure.rb

@@ -0,0 +1,12 @@
+require 'batali'
+
+module Batali
+  class Command
+
+    # Create/Update Batali configuration
+    class Configure < Batali::Command
+
+    end
+
+  end
+end

data/lib/batali/command/install.rb

@@ -0,0 +1,45 @@
+require 'batali'
+require 'fileutils'
+
+module Batali
+  class Command
+
+    # Install cookbooks based on manifest
+    class Install < Batali::Command
+
+      # Install cookbooks
+      def execute!
+        dry_run('Cookbook installation') do
+          install_path = opts.fetch(:path, 'cookbooks')
+          run_action('Readying installation destination') do
+            FileUtils.rm_rf(install_path)
+            FileUtils.mkdir_p(install_path)
+            nil
+          end
+          run_action('Installing cookbooks') do
+            manifest.cookbook.each do |unit|
+              asset_path = unit.source.asset
+              begin
+                FileUtils.mv(
+                  File.join(
+                    asset_path,
+                    unit.name
+                  ),
+                  File.join(
+                    install_path,
+                    unit.name
+                  )
+                )
+              ensure
+                FileUtils.rm_rf(asset_path)
+              end
+            end
+            nil
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/batali/command/resolve.rb

@@ -0,0 +1,71 @@
+require 'batali'
+
+module Batali
+  class Command
+
+    # Resolve cookbooks
+    class Resolve < Command
+
+      # Resolve dependencies and constraints. Output results to stdout
+      # and dump serialized manifest
+      def execute!
+        system = Grimoire::System.new
+        run_action 'Loading sources' do
+          batali_file.source.map(&:units).flatten.map do |unit|
+            system.add_unit(unit)
+          end
+          nil
+        end
+        requirements = Grimoire::RequirementList.new(
+          :name => :batali_resolv,
+          :requirements => batali_file.cookbook.map{ |ckbk|
+            [ckbk.name, *(ckbk.constraint.empty? ? ['> 0'] : ckbk.constraint)]
+          }
+        )
+        solv = Grimoire::Solver.new(
+          :requirements => requirements,
+          :system => system,
+          :score_keeper => score_keeper
+        )
+        results = []
+        run_action 'Resolving dependency constraints' do
+          results = solv.generate!
+          nil
+        end
+        if(results.empty?)
+          ui.error 'No solutions found defined requirements!'
+        else
+          ideal_solution = results.pop
+          dry_run('manifest file write') do
+            run_action 'Writing manifest' do
+              manifest = Manifest.new(:cookbook => ideal_solution.units)
+              File.open('batali.manifest', 'w') do |file|
+                file.write MultiJson.dump(manifest, :pretty => true)
+              end
+              nil
+            end
+          end
+          ui.info "Found #{results.size} solutions for defined requirements."
+          ui.info 'Ideal solution:'
+          ui.puts ideal_solution.units.sort_by(&:name).map{|u| "#{u.name}<#{u.version}>"}
+        end
+      end
+
+      # @return [ScoreKeeper]
+      def score_keeper
+        memoize(:score_keeper) do
+          sk_manifest = Manifest.new(:cookbook => manifest.cookbook)
+          unless(opts[:least_impact])
+            sk_manifest.cookbook.clear
+          end
+          sk_manifest.cookbook.delete_if do |unit|
+            arguments.include?(unit.name)
+          end
+          ScoreKeeper.new(:manifest => sk_manifest)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/batali/command/update.rb

@@ -0,0 +1,17 @@
+require 'batali'
+
+module Batali
+  class Command
+
+    # Update cookbook manifest
+    class Update < Batali::Command
+
+      def execute!
+        Resolve.new({:resolve => opts}, arguments).execute!
+        Install.new({:install => opts}, arguments).execute!
+      end
+
+    end
+
+  end
+end

data/lib/batali/command.rb

@@ -0,0 +1,48 @@
+require 'batali'
+
+module Batali
+  # Customized command base for Batali
+  class Command < Bogo::Cli::Command
+
+    include Bogo::Memoization
+
+    autoload :Configure, 'batali/command/configure'
+    autoload :Install, 'batali/command/install'
+    autoload :Resolve, 'batali/command/resolve'
+    autoload :Update, 'batali/command/update'
+
+    # @return [BFile]
+    def batali_file
+      memoize(:batali_file) do
+        # TODO: Add directory traverse searching
+        BFile.new(opts.fetch(:file, File.join(Dir.pwd, 'Batali')))
+      end
+    end
+
+    # @return [Manifest]
+    def manifest
+      memoize(:manifest) do
+        Manifest.build(
+          File.join(
+            File.dirname(
+              opts.fetch(:file, File.join(Dir.pwd, 'batali.manifest'))
+            ), 'batali.manifest'
+          )
+        )
+      end
+    end
+
+    # Do not execute block if dry run
+    #
+    # @param action [String] action to be performed
+    # @yield block to execute
+    def dry_run(action)
+      if(opts[:dry_run])
+        ui.warn "Dry run disabled: #{action}"
+      else
+        yield
+      end
+    end
+
+  end
+end

data/lib/batali/config.rb

@@ -0,0 +1,7 @@
+require 'batali'
+
+module Batali
+  class Config < Bogo::Config
+
+  end
+end

data/lib/batali/manifest.rb

@@ -0,0 +1,42 @@
+require 'batali'
+
+module Batali
+  # Collection of resolved units
+  class Manifest < Grimoire::Utility
+
+    include Bogo::Memoization
+
+    attribute :cookbook, Unit, :multiple => true, :coerce => lambda{|v| Unit.new(v)}
+
+    # Build manifest from given path. If no file exists, empty
+    # manifest will be provided.
+    #
+    # @param path [String] path to manifest
+    # @return [Manifest]
+    def self.build(path)
+      if(File.exists?(path))
+        self.new(Bogo::Config.new(path).data)
+      else
+        self.new
+      end
+    end
+
+    # Check for unit within manifest
+    #
+    # @param unit [Unit]
+    # @return [TrueClass, FalseClass]
+    def include?(unit)
+      memoize(unit.inspect) do
+        if(cookbook)
+          !!cookbook.detect do |ckbk|
+            ckbk.name == unit.name &&
+              ckbk.version == unit.version
+          end
+        else
+          false
+        end
+      end
+    end
+
+  end
+end

data/lib/batali/monkey.rb

@@ -0,0 +1,26 @@
+require 'batali'
+
+module Batali
+  # Simple stubs mostly for naming
+  class UnitVersion < Grimoire::VERSION_CLASS; end
+  class UnitRequirement < Grimoire::REQUIREMENT_CLASS; end
+  class UnitDependency < Grimoire::DEPENDENCY_CLASS
+    def to_json(*args)
+      result = [
+        name,
+        *requirement.requirements.map do |req|
+          req.join(' ')
+        end
+      ]
+      MultiJson.dump(result, *args)
+    end
+  end
+end
+
+Grimoire.send(:remove_const, :VERSION_CLASS)
+Grimoire.send(:remove_const, :DEPENDENCY_CLASS)
+Grimoire.send(:remove_const, :REQUIREMENT_CLASS)
+
+Grimoire.const_set(:VERSION_CLASS, Batali::UnitVersion)
+Grimoire.const_set(:DEPENDENCY_CLASS, Batali::UnitDependency)
+Grimoire.const_set(:REQUIREMENT_CLASS, Batali::UnitRequirement)

data/lib/batali/remote_site.rb

@@ -0,0 +1,98 @@
+require 'batali'
+require 'digest/sha2'
+require 'securerandom'
+require 'http'
+require 'fileutils'
+
+module Batali
+  # Fetch unit information from remote site
+  class RemoteSite < Grimoire::Utility
+
+    # Site suffix for API endpoint
+    COOKBOOK_API_SUFFIX = 'api/v1/cookbooks'
+
+    include Bogo::Memoization
+
+    attribute :name, String
+    attribute :identifier, String
+    attribute :endpoint, String, :required => true
+    attribute :force_update, [TrueClass, FalseClass], :required => true, :default => false
+    attribute :update_interval, Integer, :required => true, :default => 10000 # NOTE: reset this default to 60/120 when ready
+    attribute :cache, String, :default => File.expand_path('~/.batali/cache/remote_site'), :required => true
+
+    def initialize(*_)
+      super
+      endpoint = URI.join(self.endpoint, COOKBOOK_API_SUFFIX).to_s
+      self.identifier = Digest::SHA256.hexdigest(endpoint)
+      unless(name?)
+        self.name = self.identifier
+      end
+    end
+
+    # @return [String] cache directory path
+    def cache_directory
+      memoize(:cache_directory) do
+        path = File.join(cache, identifier)
+        FileUtils.mkdir_p(path)
+        path
+      end
+    end
+
+    # @return [Array<Unit>] all units
+    def units
+      memoize(:units) do
+        items.map do |u_name, versions|
+          versions.map do |version, info|
+            Unit.new(
+              :name => u_name,
+              :version => version,
+              :dependencies => info[:dependencies].to_a,
+              :source => Smash.new(
+                :type => :site,
+                :url => info[:download_url],
+                :version => version,
+                :dependencies => info[:dependencies]
+              )
+            )
+          end
+        end.flatten
+      end
+    end
+
+    protected
+
+    # @return [Smash] all info
+    def items
+      memoize(:items) do
+        MultiJson.load(File.read(fetch)).to_smash
+      end
+    end
+
+    # Fetch the universe
+    #
+    # @return [String] path to universe file
+    def fetch
+      do_fetch = true
+      if(File.exists?(universe_path))
+        age = Time.now - File.mtime(universe_path)
+        if(age < update_interval)
+          do_fetch = false
+        end
+      end
+      if(do_fetch)
+        t_uni = "#{universe_path}.#{SecureRandom.urlsafe_base64}"
+        File.open(t_uni, 'w') do |file|
+          file.write HTTP.get(URI.join(endpoint, 'universe')).body.to_s
+        end
+        FileUtils.mv(t_uni, universe_path)
+      end
+      universe_path
+    end
+
+    # @return [String] path to universe file
+    def universe_path
+      File.join(cache_directory, 'universe.json')
+    end
+
+  end
+end

data/lib/batali/score_keeper.rb

@@ -0,0 +1,18 @@
+require 'batali'
+
+module Batali
+  # Provide scores for units
+  class ScoreKeeper < Grimoire::UnitScoreKeeper
+
+    attribute :manifest, Manifest, :required => true
+
+    # Provide score for given unit
+    #
+    # @param unit [Unit]
+    # @return [Numeric, NilClass]
+    def score_for(unit)
+      manifest.include?(unit) ? 0 : nil
+    end
+
+  end
+end

data/lib/batali/source/path.rb

@@ -0,0 +1,26 @@
+require 'batali'
+require 'fileutils'
+require 'tmpdir'
+
+module Batali
+  # Source of asset
+  class Source
+    # Path based source
+    class Path < Source
+
+      include Bogo::Memoization
+
+      attribute :path, String, :required => true
+
+      # @return [String] directory containing contents
+      def asset
+        memoize(:asset) do
+          dir = Dir.mktmpdir
+          FileUtils.cp_r(path, dir)
+          dir
+        end
+      end
+
+    end
+  end
+end

data/lib/batali/source/site.rb

@@ -0,0 +1,70 @@
+require 'batali'
+require 'http'
+require 'tmpdir'
+require 'rubygems/package'
+require 'zlib'
+
+module Batali
+  class Source
+    # Site based source
+    class Site < Source
+
+      # @return [Array<Hash>] dependency strings
+      attr_reader :dependencies
+      # @return [String] version
+      attr_reader :version
+
+      attribute :url, String, :required => true
+      attribute :version, String, :required => true
+
+      # Extract extra info before allowing super to load data
+      #
+      # @param args [Hash]
+      # @return [self]
+      def initialize(args={})
+        @deps = args.delete(:dependencies) || {}
+        super
+      end
+
+      # @return [String]
+      def unit_version
+        version
+      end
+
+      # @return [Array<Array<name, constraints>>]
+      def unit_dependencies
+        deps.to_a
+      end
+
+      # @return [String] directory
+      def asset
+        path = Dir.mktmpdir('batali')
+        result = HTTP.get(url)
+        while(result.code == 302)
+          result = HTTP.get(result.headers['Location'])
+        end
+        File.open(a_path = File.join(path, 'asset'), 'w') do |file|
+          while(content = result.body.readpartial(2048))
+            file.write content
+          end
+        end
+        ext = Gem::Package::TarReader.new(
+          Zlib::GzipReader.open(a_path)
+        )
+        ext.rewind
+        ext.each do |entry|
+          next unless entry.file?
+          n_path = File.join(path, entry.full_name)
+          FileUtils.mkdir_p(File.dirname(n_path))
+          File.open(n_path, 'w') do |file|
+            while(content = entry.read(2048))
+              file.write(content)
+            end
+          end
+        end
+        path
+      end
+
+    end
+  end
+end

data/lib/batali/source.rb

@@ -0,0 +1,45 @@
+require 'batali'
+
+module Batali
+  # Source of asset
+  class Source < Grimoire::Utility
+
+    autoload :Path, 'batali/source/path'
+    autoload :Site, 'batali/source/site'
+    autoload :Git, 'batali/source/git'
+
+    attribute :type, String, :required => true, :default => lambda{ self.name }
+
+    # @return [String]
+    def unit_version
+      raise NotImplementedError.new 'Abstract class'
+    end
+
+    # @return [Array<Array<name, constraints>>]
+    def unit_dependencies
+      raise NotImplementedError.new 'Abstract class'
+    end
+
+    # @return [String] directory containing contents
+    def asset
+      raise NotImplementedError.new 'Abstract class'
+    end
+
+    # Build a source
+    #
+    # @param args [Hash]
+    # @return [Source]
+    # @note uses `:type` to build concrete source
+    def self.build(args)
+      type = args.delete(:type)
+      unless(type)
+        raise ArgumentError.new 'Missing required option `:type`!'
+      end
+      unless(type.to_s.include?('::'))
+        type = [self.name, Bogo::Utility.camel(type)].join('::')
+      end
+      Bogo::Utility.constantize(type).new(args.merge(:type => type))
+    end
+
+  end
+end

data/lib/batali/unit.rb

@@ -0,0 +1,8 @@
+require 'batali'
+
+module Batali
+  # Customized Unit
+  class Unit < Grimoire::Unit
+    attribute :source, Source, :required => true, :coerce => lambda{|v| Batali::Source.build(v)}
+  end
+end

data/lib/batali/version.rb

@@ -1,3 +1,3 @@
 module Batali
-  VERSION = Gem::Version.new('0.0.1')
+  VERSION = Gem::Version.new('0.1.0')
 end

data/lib/batali.rb

@@ -0,0 +1,18 @@
+require 'bogo-cli'
+require 'grimoire'
+
+module Batali
+
+  autoload :Command, 'batali/command'
+  autoload :Config, 'batali/config'
+  autoload :Manifest, 'batali/manifest'
+  autoload :RemoteSite, 'batali/remote_site'
+  autoload :ScoreKeeper, 'batali/score_keeper'
+  autoload :Source, 'batali/source'
+  autoload :Unit, 'batali/unit'
+
+end
+
+require 'batali/b_file'
+require 'batali/monkey'
+require 'batali/version'

metadata

@@ -1,15 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: batali
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2015-03-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: grimoire
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: bogo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.12
+- !ruby/object:Gem::Dependency
+  name: bogo-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+- !ruby/object:Gem::Dependency
+  name: bogo-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.10
+- !ruby/object:Gem::Dependency
+  name: http
+  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: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -40,7 +110,8 @@ dependencies:
         version: '0'
 description: Magic
 email: code@chrisroberts.org
-executables: []
+executables:
+- batali
 extensions: []
 extra_rdoc_files: []
 files:
@@ -49,6 +120,23 @@ files:
 - LICENSE
 - README.md
 - batali.gemspec
+- bin/batali
+- lib/batali.rb
+- lib/batali/b_file.rb
+- lib/batali/command.rb
+- lib/batali/command/configure.rb
+- lib/batali/command/install.rb
+- lib/batali/command/resolve.rb
+- lib/batali/command/update.rb
+- lib/batali/config.rb
+- lib/batali/manifest.rb
+- lib/batali/monkey.rb
+- lib/batali/remote_site.rb
+- lib/batali/score_keeper.rb
+- lib/batali/source.rb
+- lib/batali/source/path.rb
+- lib/batali/source/site.rb
+- lib/batali/unit.rb
 - lib/batali/version.rb
 homepage: https://github.com/hw-labs/batali
 licenses: