homebrew_automation 0.0.4 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0afb1407753967ec435daea068803517ef0daeda28eb6bbc5407176499714a6c
-  data.tar.gz: d07ac2517ffd1a629372e0802bdfb38c19712216ca75fbdd6dcb50e5b78e9cb4
+  metadata.gz: 97e03de71e29414ed00f37914b8964e91421465de75ffd1cd39c85a4ceb274da
+  data.tar.gz: da6cf8c8bd4e2ad86ccd2f0242c0407ef2955b74e5fc70c8b0fbf39e1fa6ffe9
 SHA512:
-  metadata.gz: e1d8400c5edcefe664f0c29e955309b56b96023990961bcf4cd697088c5b57ba5e75906d851083330c6522f5938c726a966828d98236752d3711d4db21d4907c
-  data.tar.gz: 60b4bf05c87d8df1e8224cb73998cdc6a6e793d111296b272348c3d888dff5e111aa93207c494da27a05ac2e17459b635d41bf027b4f44aed6546b11a0b38bb6
+  metadata.gz: 6ee552dac8c240c7585073046f2c6c1385bbd65802146aa55bd1e6bd074b9d122d8e018b2135ca13ee053df4f3bd113b52f687906bd08858748bdf0f03f1d83d
+  data.tar.gz: 6dd74ac44f8d465976426baf3f201ca5786d15e9f9c557610e19297d870764eef511390cfcbeeb1e7d5a5b5eb7ccba2b0d242668129e21c3bf765ec513030e38

data/bin/homebrew_automation.rb

@@ -2,22 +2,20 @@
 
 require 'thor'
 
-require 'homebrew_automation'
+require_relative '../lib/homebrew_automation.rb'
 
-class MyCliApp < Thor
+class FormulaCommands < Thor
 
-  desc 'put-sdist', 'update the URL and sha256 checksum of the source tarball'
+  desc 'put-sdist', 'Update the URL and sha256 checksum of the source tarball'
   option :url, :required => true
   option :sha256, :required => true
   def put_sdist
     before = HomebrewAutomation::Formula.parse_string($stdin.read)
-    after = before.
-      update_field("url", options[:url]).
-      update_field("sha256", options[:sha256])
+    after = before.put_sdist options[:url], options[:sha256]
     $stdout.write after
   end
 
-  desc 'put-bottle', 'insert or update a bottle reference for a given OS'
+  desc 'put-bottle', 'Insert or update a bottle reference for a given OS'
   option :os, :required => true
   option :sha256, :required => true
   def put_bottle
@@ -28,6 +26,74 @@ class MyCliApp < Thor
 
 end
 
+class WorkflowCommands < Thor
+  class_option :tap_user, :required => true
+  class_option :tap_repo, :required => true
+  class_option :tap_token, :required => true
+  class_option :bintray_user, :required => true
+  class_option :bintray_token, :required => true
+
+  desc 'build-and-upload', 'Build binary tarball from source tarball, then upload to Bintray'
+  long_desc <<-HERE_HERE
+    Since we're uploading to Bintray, we need a Bintray API KEY at `bintray_token`.
+
+    `formula_name` defaults to the same as `source_repo`.
+    `formula_version` defaults to `source_tag` with a leading `v` stripped off.
+  HERE_HERE
+  option :source_user, :required => true
+  option :source_repo, :required => true
+  option :source_tag, :required => true
+  option :formula_name
+  option :formula_version
+  def build_and_upload
+    workflow.build_and_upload_bottle(
+      HomebrewAutomation::SourceDist.new(
+        options[:source_user],
+        options[:source_repo],
+        options[:source_tag]),
+      formula_name: options[:formula_name],
+      version_name: options[:formula_version])
+  end
+
+  desc 'gather-and-publish', 'Make the Tap aware of new Bottles'
+  long_desc <<-HERE_HERE
+    See what bottles have been built and uploaded to Bintray, then publish them into the Tap.
+
+    Since we're publishing updates to the Formula in our Tap, we need Git push access to the
+    Tap repo on Github via a Github OAuth token via `tap_token`.
+
+    `formula-name` should be both the formula name as appears in the Tap and also the Bintray package name.
+    `formula-version` should be the Bintray "Version" name.
+  HERE_HERE
+  option :formula_name, :required => true
+  option :formula_version, :required => true
+  def gather_and_publish
+    workflow.gather_and_publish_bottles(
+      options[:formula_name],
+      options[:formula_version])
+  end
+
+  private
+
+  def workflow
+    HomebrewAutomation::Workflow.new(
+      HomebrewAutomation::Tap.new(options[:tap_user], options[:tap_repo], options[:tap_token]),
+      HomebrewAutomation::Bintray.new(options[:bintray_user], options[:bintray_token]))
+  end
+
+end
+
+class MyCliApp < Thor
+
+  desc 'formula (...)', 'Modify Formula DSL source (read stdin, write stdout)'
+  subcommand "formula", FormulaCommands
+
+  desc 'bottle (...)', 'Workflows for dealing with binary artifacts'
+  subcommand "bottle", WorkflowCommands
+
+end
+
+
 MyCliApp.start(ARGV)
 
 

data/lib/homebrew_automation/bintray.rb

@@ -0,0 +1,86 @@
+
+require 'json'
+require 'base64'
+require 'uri'
+require 'rest-client'
+
+module HomebrewAutomation
+
+  class Bintray
+
+    def initialize(
+        username,
+        api_key,
+        http: RestClient,
+        base_url: "https://bintray.com/api/v1"
+    )
+      @username = username
+      @api_key = api_key
+      @base_url = base_url
+      @http = http  # allow injecting mocks for testing
+    end
+
+    # POST /packages/:subject/:repo/:package/versions
+    #
+    # Redundant: Bintray seems to create nonexistant versions for you if you
+    # just try to upload files into it.
+    def create_version(repo_name, package_name, version_name)
+      safe_repo = URI.escape(repo_name)
+      safe_pkg = URI.escape(package_name)
+      @http.post(
+        rel("/packages/#{safe_username}/#{safe_repo}/#{safe_pkg}/versions"),
+        { name: version_name }.to_json,
+        api_headers
+      )
+    end
+
+    # PUT /content/:subject/:repo/:package/:version/:file_path[?publish=0/1][?override=0/1][?explode=0/1]
+    #
+    # Bintray seems to expect the byte sequence of the file to be written straight out into the
+    # HTTP request body, optionally via `Transfer-Encoding: chunked`. So we pass the `content` String
+    # straight through to RestClient
+    def upload_file(repo_name, package_name, version_name, filename, content, publish: 1)
+      safe_repo = URI.escape(repo_name)
+      safe_pkg = URI.escape(package_name)
+      safe_ver = URI.escape(version_name)
+      safe_filename = URI.escape(filename)
+      safe_publish = URI.escape(publish.to_s)
+      @http.put(
+        rel("/content/#{safe_username}/#{safe_repo}/#{safe_pkg}/#{safe_ver}/#{safe_filename}?publish=#{safe_publish}"),
+        content,
+        auth_headers
+      )
+    end
+
+    # GET /packages/:subject/:repo/:package/versions/:version/files[?include_unpublished=0/1]
+    def get_all_files_in_version(repo_name, package_name, version_name)
+      safe_repo = URI.escape(repo_name)
+      safe_pkg = URI.escape(package_name)
+      safe_ver = URI.escape(version_name)
+      @http.get(
+        rel("/packages/#{safe_username}/#{safe_repo}/#{safe_pkg}/versions/#{safe_ver}/files"),
+        auth_headers)
+    end
+
+    def safe_username
+      URI.escape(@username)
+    end
+
+    # Expand relative path
+    def rel(slash_subpath)
+      @base_url + slash_subpath
+    end
+
+    def api_headers
+      { "Content-Type" => "application/json" }.update auth_headers
+    end
+
+    def auth_headers
+      # As per RFC 7617
+      cred = Base64.strict_encode64("#{@username}:#{@api_key}")
+      { Authorization: "Basic #{cred}" }
+    end
+
+  end
+
+end

data/lib/homebrew_automation/bottle.rb

@@ -0,0 +1,74 @@
+
+
+module HomebrewAutomation
+
+  class Bottle
+
+    def initialize(
+        tap_url,
+        formula_name,
+        os_name,
+        filename: nil,
+        content: nil)
+      @tap_url = tap_url
+      @formula_name = formula_name
+      @os_name = os_name
+      @filename = filename
+      @minus_minus = nil  # https://github.com/Homebrew/brew/pull/4612
+      @content = content
+    end
+
+    # Takes ages to run, just like if done manually
+    def build
+      die unless system 'brew', 'tap', local_tap_name, @tap_url
+      die unless system 'brew', 'install', '--verbose', '--build-bottle', @formula_name
+      die unless system 'brew', 'bottle', '--verbose', '--json', @formula_name
+    end
+
+    # Read and analyse metadata JSON file
+    def locate_tarball
+      json_filename = Dir['*.bottle.json'].first
+      unless json_filename
+        build
+        return locate_tarball
+      end
+      json = JSON.parse(File.read(json_filename))
+      focus = json || die
+      focus = focus[json.keys.first] || die
+      focus = focus['bottle'] || die
+      focus = focus['tags'] || die
+      focus = focus[@os_name] || die
+      @minus_minus, @filename = focus['local_filename'], focus['filename']
+    end
+
+    def minus_minus
+      @minus_minus || locate_tarball.first
+    end
+
+    def filename
+      @filename || locate_tarball.last
+    end
+
+    def load_tarball_from_disk
+      File.rename minus_minus, filename
+      @content = File.read filename
+    end
+
+    def content
+      @content || load_tarball_from_disk
+    end
+
+    private
+
+    # A name for the temporary tap; doesn't really matter what this is.
+    def local_tap_name
+      'easoncxz/local-tap'
+    end
+
+    def die
+      raise StandardError.new
+    end
+
+  end
+
+end

data/lib/homebrew_automation/bottle_gatherer.rb

@@ -0,0 +1,51 @@
+
+require_relative './mac-os.rb'
+require_relative './formula.rb'
+
+module HomebrewAutomation
+
+  # Some functions for figuring out, from files on Bintray, what values to use in bottle DSL.
+  class BottleGatherer
+
+    # @param json [Hash]  List of files from Bintray
+    def initialize(json)
+      @json = json
+      @bottles = nil
+    end
+
+    # () -> Hash String String
+    #
+    # Returns a hash with keys being OS names (in Homebrew-form) and values being SHA256 checksums
+    def bottles
+      return @bottles if @bottles
+      pairs = @json.map do |f|
+        os = parse_for_os(f['name'])
+        checksum = f['sha256']
+        [os, checksum]
+      end
+      @bottles = Hash[pairs]
+    end
+
+    # Formula -> Formula
+    #
+    # Put all bottles gathered here into the given formula, then return the result
+    def put_bottles_into(formula)
+      bottles.reduce(formula) do |formula, (os, checksum)|
+        formula.put_bottle(os, checksum)
+      end
+    end
+
+    #private
+
+    # String -> String
+    #
+    # filename -> OS name
+    def parse_for_os(bottle_filename)
+      File.extname(
+        File.basename(bottle_filename, '.bottle.tar.gz')).
+      sub(/^\./, '')
+    end
+
+  end
+
+end

data/lib/homebrew_automation/formula.rb

@@ -0,0 +1,217 @@
+
+require 'parser/current'
+require 'unparser'
+
+Parser::Builders::Default.emit_lambda = true
+Parser::Builders::Default.emit_procarg0 = true
+
+module HomebrewAutomation
+
+  # An internal representation of some Formula.rb Ruby source file, containing
+  # the definition of a Homebrew Bottle. See Homebrew docs for concepts:
+  # https://docs.brew.sh/Bottles.html
+  #
+  # Instance methods produce new instances where applicable, leaving all
+  # instances free from mutation.
+  class Formula
+
+    # A constructor method that parses the string form of a Homebrew Formula
+    # source file into an internal representation
+    #
+    # @return [Formula]
+    def self.parse_string s
+      Formula.new (Parser::CurrentRuby.parse s)
+    end
+
+    # Take an post-parsing abstract syntax tree representation of a Homebrew Formula.
+    # This is mostly not intended for common use-cases.
+    #
+    # @param ast [Parser::AST::Node]
+    def initialize ast
+      @ast = ast
+    end
+
+    # Produce Homebrew Formula source code as a string, suitable for saving as
+    # a Ruby source file.
+    #
+    # @return [String]
+    def to_s
+      Unparser.unparse @ast
+    end
+
+    # Update a field in the Formula
+    #
+    # @param field [String] Name of the Formula field, e.g. `url`
+    # @param value [String] Value of the Formula field, e.g. `https://github.com/easoncxz/homebrew-automation`
+    # @return [Formula] a new instance of Formula with the changes applied
+    def update_field field, value
+      Formula.new update(
+        @ast,
+        [ by_type('begin'),
+          by_both(
+            by_type('send'),
+            by_msg(field)),
+          by_type('str')],
+        -> (n) { n.updated(nil, [value]) })
+    end
+
+    # Update two fields together
+    #
+    # @param url [String] URL of source tarball
+    # @param sha256 [String] SHA256 sum of source tarball
+    def put_sdist url, sha256
+      update_field("url", url).
+      update_field("sha256", sha256)
+    end
+
+    # Insert or replace the Homebrew Bottle for a given OS
+    #
+    # @param os [String] Operating system name, e.g. "yosemite", as per Homebrew's conventions
+    # @param sha256 [String] Checksum of the binary "Bottle" tarball
+    # @return [Formula] a new instance of Formula with the changes applied
+    def put_bottle os, sha256
+      Formula.new update(
+        @ast,
+        bot_begin_path,
+        put_bottle_version(os, sha256))
+    end
+
+    def == o
+      self.class == o.class && @ast == o.ast
+    end
+
+    def hash
+      @ast.hash
+    end
+
+    alias :eql? :==
+
+    protected
+    attr_reader :ast
+
+    private
+
+    # Path to the :begin node
+    # bot_begin_path :: [Choice]
+    # type Choice = Proc (Node -> Bool)
+    def bot_begin_path
+      [ by_type('begin'),
+        by_both(
+          by_type('block'),
+          by_child(
+            by_both(
+              by_type('send'),
+              by_msg('bottle')))),
+        by_type('begin')]
+    end
+
+    # Tricky: this is an insert-or-update
+    # put_bottle_version :: String -> String -> Proc (Node -> Node)
+    def put_bottle_version os, sha256
+      -> (bot_begin) {
+        bot_begin.updated(
+          nil,  # keep the node type unchanged
+          bot_begin.children.reject(
+            # Get rid of any existing matching ones
+            &by_both(
+              by_msg('sha256'),
+              by_os(os))
+          # Then add the one we want
+          ).push(new_sha256(sha256, os)))
+      }
+    end
+
+    # Build a new AST Node
+    # String -> String -> Node
+    def new_sha256 sha256, os
+      # Unparser doesn't like Sexp, so let's bring
+      # own own bit of "source code" inline.
+      sha256_send = Parser::CurrentRuby.parse(
+        'sha256 "checksum-here" => :some_os')
+      with_sha256 = update(
+        sha256_send,
+        [ by_type('hash'),
+          by_type('pair'),
+          by_type('str') ],
+        -> (n) { n.updated(nil, [sha256]) })
+      with_sha256_and_os = update(
+        with_sha256,
+        [ by_type('hash'),
+          by_type('pair'),
+          by_type('sym') ],
+        -> (n) { n.updated(nil, [os.to_sym]) })
+      with_sha256_and_os
+    end
+
+    # update :: Node -> [Choice] -> Proc (Node -> Node) -> Node
+    def update node, path, fn
+      if path.length == 0 then
+        fn.(node)
+      else
+        choose, *rest = path
+        node.updated(
+          nil,    # Don't change node type
+          node.children.map do |c|
+            choose.(c) ? update(c, rest, fn) : c
+          end)
+      end
+    end
+
+    # zoom_in :: Node -> [Choice] -> Node
+    def zoom_in node, path
+      if path.length == 0 then
+        node
+      else
+        choose, *rest = path
+        chosen = node.children.select(&choose).first
+        zoom_in chosen, rest
+      end
+    end
+
+    # by_both
+    #   :: Proc (Node -> Bool)
+    #   -> Proc (Node -> Bool)
+    #   -> Proc (Node -> Bool)
+    def by_both p, q
+      -> (n) { p.(n) && q.(n) }
+    end
+
+    # by_msg :: String -> Proc (Node -> Bool)
+    def by_msg msg
+      -> (n) { n.children[1] == msg.to_sym }
+    end
+
+    # by_type :: String -> Proc (Node -> Bool)
+    def by_type type
+      -> (n) {
+        n &&
+        n.is_a?(AST::Node) &&
+        n.type == type.to_sym
+      }
+    end
+
+    # Matches if one of the node's children matches the given p
+    # by_child :: Proc (Node -> Bool) -> Proc (Node -> Bool)
+    def by_child p
+      -> (n) {
+        n &&
+        n.is_a?(AST::Node) &&
+        n.children.select(&p).size > 0
+      }
+    end
+
+    # Matches if this :send node expresses the give sha256 sum
+    # by_os :: String -> Proc (Node -> Bool)
+    def by_os os
+      -> (n) {
+        zoom_in(n, [
+          by_type('hash'),
+          by_type('pair'),
+          by_type('sym')])
+        .children[0] == os.to_sym
+      }
+    end
+
+  end
+
+end

data/lib/homebrew_automation/mac-os.rb

@@ -0,0 +1,29 @@
+
+module HomebrewAutomation
+
+  class MacOS
+
+    # () -> String
+    #
+    # Returns a representation of the macOS version name in a format recognised by Homebrew,
+    # in particular the Formula/Bottle DSL.
+    def self.identify_version
+      version = `sw_vers -productVersion`
+      mac_to_homebrew.
+        select { |pattern, _| pattern === version }.
+        map { |_, description| description }.
+        first
+    end
+
+    def self.mac_to_homebrew
+      {
+        /^10.10/ => 'yosemite',
+        /^10.11/ => 'el_capitan',
+        /^10.12/ => 'sierra',
+        /^10.13/ => 'high_sierra'
+      }
+    end
+
+  end
+
+end

data/lib/homebrew_automation/source_dist.rb

@@ -0,0 +1,52 @@
+
+require 'http'
+
+module HomebrewAutomation
+
+  # A representation of a source distribution tarball file
+  class SourceDist
+
+    # @param tag [String] a Git tag, e.g. "v0.1.1.14"
+    def initialize user, repo, tag
+      @user = user
+      @repo = repo
+      @tag = tag
+    end
+
+    attr_reader :user, :repo, :tag
+
+    # Calculate and return the file's checksum. Lazy and memoized.
+    #
+    # @return [String] hex-encoded string representation of the checksum
+    def sha256
+      @sha256 ||= Digest::SHA256.hexdigest contents
+    end
+
+    # Fetch the file contents over HTTP. Lazy and memoized.
+    #
+    # @param fake [String] fake file contents (for testing)
+    # @return [String] contents of the file
+    def contents fake: nil
+      @contents = @contents || fake ||
+        begin
+          resp = HTTP.follow.get url
+          case resp.code
+          when 200
+            resp.body.to_s
+          else
+            puts resp
+            raise StandardError.new resp.code
+          end
+        end
+    end
+
+    # Pure
+    #
+    # @return [String]
+    def url
+      "https://github.com/#{@user}/#{@repo}/archive/#{@tag}.tar.gz"
+    end
+
+  end
+
+end

data/lib/homebrew_automation/tap.rb

@@ -0,0 +1,85 @@
+
+require_relative "formula.rb"
+
+module HomebrewAutomation
+
+  class Tap
+
+    # Get a token from: https://github.com/settings/tokens
+    #
+    # @param keep_submodule [Boolean] When done, don't delete the tap Git repo
+    def initialize(user, repo, token, keep_submodule: false)
+      @repo = repo
+      @url = "https://#{token}@github.com/#{user}/#{repo}.git"
+      @keep_submodule = keep_submodule
+    end
+
+    attr_reader :user, :repo, :token
+
+    # forall a. Block (() -> a) -> a
+    #
+    # Do something in a fresh clone, then clean-up.
+    def with_git_clone(&block)
+      begin
+        git_clone
+        Dir.chdir @repo, &block
+      ensure
+        remove_git_submodule unless @keep_submodule
+      end
+    end
+
+    # (String, Block (Formula -> Formula)) -> nil
+    #
+    # Overwrite the given formula
+    def on_formula(formula, &block)
+      name = "#{formula}.rb"
+      block ||= ->(n) { n }
+      Dir.chdir 'Formula' do
+        File.open name, 'r' do |old_file|
+          File.open "#{name}.new", 'w' do |new_file|
+            new_file.write(
+              block.
+                call(Formula.parse_string(old_file.read)).
+                to_s)
+          end
+        end
+        File.rename "#{name}.new", name
+      end
+    end
+
+    def git_config
+      name = ENV['TRAVIS_GIT_USER_NAME']
+      email = ENV['TRAVIS_GIT_USER_EMAIL']
+      if name && email
+        system 'git', 'config', '--global', 'user.name', name
+        system 'git', 'config', '--global', 'user.email', email
+      end
+    end
+
+    def git_commit_am(msg)
+      die unless system "git", "commit", "-am", msg
+    end
+
+    def git_push
+      die unless system "git", "push"
+    end
+
+
+    #private
+
+
+    def git_clone
+      die unless system "git", "clone", @url
+    end
+
+    def remove_git_submodule
+      die unless system "rm", "-rf", @repo
+    end
+
+    def die
+      raise StandardError.new
+    end
+
+  end
+
+end

data/lib/homebrew_automation/version.rb

@@ -1,4 +1,4 @@
 
 module HomebrewAutomation
-  VERSION = '0.0.4'
+  VERSION = '0.0.8'
 end

data/lib/homebrew_automation/workflow.rb

@@ -0,0 +1,91 @@
+
+require_relative './mac-os.rb'
+require_relative './bottle_gatherer.rb'
+
+module HomebrewAutomation
+
+  # Imperative glue code
+  #
+  # Probably each method suits to become a CLI command.
+  class Workflow
+
+    # @param tap [HomebrewAutomation::Tap]
+    # @param bintray [HomebrewAutomation::Bintray]
+    def initialize(
+        tap,
+        bintray,
+        bintray_bottle_repo: 'homebrew-bottles')
+      @tap = tap
+      @bintray = bintray
+      @bintray_bottle_repo = bintray_bottle_repo
+    end
+
+    # Build a bottle from the given source tarball reference
+    #
+    # @param source_dist [HomebrewAutomation::SourceDist] Source tarball
+    # @param formula_name [String] Formula name as appears in the Tap, which should be the same as the Bintray "Package" name
+    # @param version_name [String] Bintray package "Version" name; defaults to stripping leading `v` from the Git tag.
+    # @return [Bottle]
+    def build_and_upload_bottle(source_dist, formula_name: nil, version_name: nil)
+      formula_name ||= source_dist.repo
+      version_name ||= source_dist.tag.sub(/^v/, '')
+      os_name = MacOS.identify_version
+      @tap.with_git_clone do
+        @tap.on_formula(formula_name) do |formula|
+          formula.put_sdist(source_dist.url, source_dist.sha256)
+        end
+        @tap.git_commit_am "Throwaway commit; just for building bottles"
+
+        local_tap_url = File.realpath('.')
+        bottle = Bottle.new(local_tap_url, formula_name, os_name)
+        bottle.build
+
+        @bintray.create_version(
+          @bintray_bottle_repo,
+          formula_name,
+          version_name)
+        @bintray.upload_file(
+          @bintray_bottle_repo,
+          formula_name,
+          version_name,
+          bottle.filename,
+          bottle.content)
+
+        bottle
+      end
+    end
+
+    # Look around on Bintray to see what bottles we've previously built, then
+    # push new commits into the Tap repository to register the new bottles.
+    #
+    # @param formula_name [String]
+    # @param version_name [String] Bintray "Version" name, not a Git tag
+    # @return [Formula]
+    def gather_and_publish_bottles(formula_name, version_name)
+      @tap.with_git_clone do
+        resp = @bintray.get_all_files_in_version(
+          @bintray_bottle_repo,
+          formula_name,
+          version_name)
+        unless (200..207) === resp.code
+          puts resp
+          raise StandardError.new(resp)
+        end
+
+        json = JSON.parse(resp.body)
+        gatherer = BottleGatherer.new(json)
+
+        @tap.on_formula(formula_name) do |formula|
+          gatherer.put_bottles_into(formula)
+        end
+
+        @tap.git_config
+        @tap.git_commit_am "Add bottles for #{formula_name}@#{version_name}"
+        @tap.git_push
+      end
+    end
+
+
+  end
+
+end

data/lib/homebrew_automation.rb

@@ -1,172 +1,14 @@
 
-require 'parser/current'
-require 'unparser'
-
-Parser::Builders::Default.emit_lambda = true
-Parser::Builders::Default.emit_procarg0 = true
-
+# Helps you manipulate Homebrew Formula files, Bottles etc.
 module HomebrewAutomation
-
-  class Formula
-
-    # Formula::parse_string :: String -> Formula
-    def self.parse_string s
-      Formula.new (Parser::CurrentRuby.parse s)
-    end
-
-    # Formula::new :: Parser::AST::Node -> Formula
-    def initialize ast
-      @ast = ast
-    end
-
-    def to_s
-      Unparser.unparse @ast
-    end
-
-    # update_field :: String -> String -> Formula
-    def update_field field, value
-      Formula.new update(
-        @ast,
-        [ by_type('begin'),
-          by_both(
-            by_type('send'),
-            by_msg(field)),
-          by_type('str')],
-        -> (n) { n.updated(nil, [value]) })
-    end
-
-    # Insert or replace the bottle for a given OS
-    # put_bottle :: String -> String -> Node -> Node
-    def put_bottle os, sha256
-      Formula.new update(
-        @ast,
-        bot_begin_path,
-        put_bottle_version(os, sha256))
-    end
-
-    private
-
-    # Path to the :begin node
-    # bot_begin_path :: [Choice]
-    # type Choice = Proc (Node -> Bool)
-    def bot_begin_path
-      [ by_type('begin'),
-        by_both(
-          by_type('block'),
-          by_child(
-            by_both(
-              by_type('send'),
-              by_msg('bottle')))),
-        by_type('begin')]
-    end
-
-    # Tricky: this is an insert-or-update
-    # put_bottle_version :: String -> String -> Proc (Node -> Node)
-    def put_bottle_version os, sha256
-      -> (bot_begin) {
-        bot_begin.updated(
-          nil,  # keep the node type the unchanged
-          bot_begin.children.reject(
-            # Get rid of any existing matching ones
-            &by_both(
-              by_msg('sha256'),
-              by_os(os))
-          # Then add the one we want
-          ).push(new_sha256(sha256, os)))
-      }
-    end
-
-    # Build a new AST Node
-    # String -> String -> Node
-    def new_sha256 sha256, os
-      # Unparser doesn't like Sexp, so let's bring
-      # own own bit of "source code" inline.
-      sha256_send = Parser::CurrentRuby.parse(
-        'sha256 "checksum-here" => :some_os')
-      with_sha256 = update(
-        sha256_send,
-        [ by_type('hash'),
-          by_type('pair'),
-          by_type('str') ],
-        -> (n) { n.updated(nil, [sha256]) })
-      with_sha256_and_os = update(
-        with_sha256,
-        [ by_type('hash'),
-          by_type('pair'),
-          by_type('sym') ],
-        -> (n) { n.updated(nil, [os.to_sym]) })
-      with_sha256_and_os
-    end
-
-    # update :: Node -> [Choice] -> Proc (Node -> Node) -> Node
-    def update node, path, fn
-      if path.length == 0 then
-        fn.(node)
-      else
-        choose, *rest = path
-        node.updated(
-          nil,    # Don't change node type
-          node.children.map do |c|
-            choose.(c) ? update(c, rest, fn) : c
-          end)
-      end
-    end
-
-    # zoom_in :: Node -> [Choice] -> Node
-    def zoom_in node, path
-      if path.length == 0 then
-        node
-      else
-        choose, *rest = path
-        chosen = node.children.select(&choose).first
-        zoom_in chosen, rest
-      end
-    end
-
-    # by_both
-    #   :: Proc (Node -> Bool)
-    #   -> Proc (Node -> Bool)
-    #   -> Proc (Node -> Bool)
-    def by_both p, q
-      -> (n) { p.(n) && q.(n) }
-    end
-
-    # by_msg :: String -> Proc (Node -> Bool)
-    def by_msg msg
-      -> (n) { n.children[1] == msg.to_sym }
-    end
-
-    # by_type :: String -> Proc (Node -> Bool)
-    def by_type type
-      -> (n) {
-        n &&
-        n.is_a?(AST::Node) &&
-        n.type == type.to_sym
-      }
-    end
-
-    # Matches if one of the node's children matches the given p
-    # by_child :: Proc (Node -> Bool) -> Proc (Node -> Bool)
-    def by_child p
-      -> (n) {
-        n &&
-        n.is_a?(AST::Node) &&
-        n.children.select(&p).size > 0
-      }
-    end
-
-    # Matches if this :send node expresses the give sha256 sum
-    # by_os :: String -> Proc (Node -> Bool)
-    def by_os os
-      -> (n) {
-        zoom_in(n, [
-          by_type('hash'),
-          by_type('pair'),
-          by_type('sym')])
-        .children[0] == os.to_sym
-      }
-    end
-
-  end
-
 end
+
+require_relative 'homebrew_automation/bintray.rb'
+require_relative 'homebrew_automation/bottle.rb'
+require_relative 'homebrew_automation/bottle_gatherer.rb'
+require_relative 'homebrew_automation/formula.rb'
+require_relative 'homebrew_automation/mac-os.rb'
+require_relative 'homebrew_automation/source_dist.rb'
+require_relative 'homebrew_automation/tap.rb'
+require_relative 'homebrew_automation/version.rb'
+require_relative 'homebrew_automation/workflow.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: homebrew_automation
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.8
 platform: ruby
 authors:
 - easoncxz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-30 00:00:00.000000000 Z
+date: 2018-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
@@ -80,10 +108,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-description: |2
-      If you're thinking of manipulating Homebrew Formula files
-      e.g. during continuous integration, this is for you.
-      See the GitHub project page for usage details.
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Build Bottles and update Formulae. Please see README on Github for details.
 email: me@easoncxz.com
 executables:
 - homebrew_automation.rb
@@ -92,7 +131,15 @@ extra_rdoc_files: []
 files:
 - bin/homebrew_automation.rb
 - lib/homebrew_automation.rb
+- lib/homebrew_automation/bintray.rb
+- lib/homebrew_automation/bottle.rb
+- lib/homebrew_automation/bottle_gatherer.rb
+- lib/homebrew_automation/formula.rb
+- lib/homebrew_automation/mac-os.rb
+- lib/homebrew_automation/source_dist.rb
+- lib/homebrew_automation/tap.rb
 - lib/homebrew_automation/version.rb
+- lib/homebrew_automation/workflow.rb
 homepage: https://github.com/easoncxz/homebrew-automation
 licenses:
 - GPL-3.0
@@ -113,8 +160,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
-summary: Automate editing of Homebrew Formula files
+summary: Build bottles and update Formulae
 test_files: []