httpdisk 0.2.0 → 0.5.2

data/lib/httpdisk/grep/printer.rb

@@ -0,0 +1,99 @@
+module HTTPDisk
+  module Grep
+    class Printer
+      GREP_COLOR = '37;45'.freeze
+
+      attr_reader :output
+
+      def initialize(output)
+        @output = output
+      end
+
+      def print(path, payload, all_matches); end
+
+      protected
+
+      #
+      # helpers for subclasses
+      #
+
+      def grep_color
+        @grep_color ||= (ENV['GREP_COLOR'] || GREP_COLOR)
+      end
+
+      def print_matches(matches)
+        s = matches.first.string
+        if output.tty?
+          s = [].tap do |result|
+            ii = 0
+            matches.each do
+              result << s[ii..._1.begin(0)]
+              result << "\e["
+              result << grep_color
+              result << 'm'
+              result << _1[0]
+              result << "\e[0m"
+              ii = _1.end(0)
+            end
+            result << s[ii..]
+          end.join
+        end
+        output.puts s
+      end
+    end
+
+    #
+    # subclasses
+    #
+
+    # path:count
+    class CountPrinter < Printer
+      def print(path, _payload, all_matches)
+        output.puts "#{path}:#{all_matches.length}"
+      end
+    end
+
+    # header, then each match
+    class HeaderPrinter < Printer
+      attr_reader :head, :printed
+
+      def initialize(output, head)
+        super(output)
+        @head = head
+        @printed = 0
+      end
+
+      def print(path, payload, all_matches)
+        # separator & filename
+        output.puts if (@printed += 1) > 1
+        output.puts path
+
+        # --head
+        if head
+          io = StringIO.new
+          payload.write_header(io)
+          io.string.lines.each { output.puts "< #{_1}" }
+        end
+
+        # matches
+        all_matches.each { print_matches(_1) }
+      end
+    end
+
+    class SilentPrinter < Printer
+      def initialize
+        super(nil)
+      end
+    end
+
+    # each match as path:match
+    class TersePrinter < Printer
+      def print(path, _payload, all_matches)
+        all_matches.each do
+          output.write("#{path}:")
+          print_matches(_1)
+        end
+      end
+    end
+  end
+end

data/lib/httpdisk/payload.rb

@@ -39,11 +39,11 @@ module HTTPDisk
       @headers = Faraday::Utils::Headers.new
     end
 
-    def error_999?
-      status == HTTPDisk::ERROR_STATUS
+    def error?
+      status >= 400
     end
 
-    def write(f)
+    def write_header(f)
       # comment
       f.puts "# #{comment}"
 
@@ -52,9 +52,11 @@ module HTTPDisk
 
       # headers
       headers.each { f.puts("#{_1}: #{_2}") }
-      f.puts
+    end
 
-      # body
+    def write(f)
+      write_header(f)
+      f.puts
       f.write(body)
     end
   end

data/lib/httpdisk/slop_duration.rb

@@ -0,0 +1,24 @@
+require 'slop'
+
+module Slop
+  # Custom duration type for Slop, used for --expires. Raises aggressively
+  # because this is a tricky and lightly documented option.
+  class DurationOption < Option
+    UNITS = {
+      s: 1,
+      m: 60,
+      h: 60 * 60,
+      d: 24 * 60 * 60,
+      w: 7 * 24 * 60 * 60,
+      y: 365 * 7 * 24 * 60 * 60,
+    }.freeze
+
+    def call(value)
+      m = value.match(/^(\d+)([smhdwy])?$/)
+      raise Slop::Error, "invalid --expires #{value.inspect}" if !m
+
+      num, unit = m[1].to_i, (m[2] || 's').to_sym
+      num * UNITS[unit]
+    end
+  end
+end

data/lib/httpdisk/sloptions.rb

@@ -0,0 +1,105 @@
+module HTTPDisk
+  # Like Slop, but for sanity checking method options. Useful for library entry
+  # points that want to be strict. Example usage:
+  #
+  # options = Sloptions.new(options) do
+  #   _1.boolean :force
+  #   _1.integer :retries, required: true
+  #   _1.string :hello, default: 'world'
+  #   ...
+  # end
+  class Sloptions
+    attr_reader :flags
+
+    def self.parse(options, &block)
+      Sloptions.new(&block).parse(options)
+    end
+
+    def initialize
+      @flags = {}
+      yield(self)
+    end
+
+    #
+    # _1.on and friends
+    #
+
+    def on(flag, foptions = {})
+      raise ":#{flag} already defined" if flags[flag]
+
+      flags[flag] = foptions
+    end
+
+    %i[array boolean float hash integer string symbol].each do |method|
+      define_method(method) do |flag, foptions = {}|
+        on(flag, { type: method }.merge(foptions))
+      end
+    end
+    alias bool boolean
+
+    #
+    # return parsed options
+    #
+
+    def parse(options)
+      # defaults
+      options = defaults.merge(options.compact)
+
+      flags.each do |flag, foptions|
+        # nil check
+        value = options[flag]
+        if value.nil?
+          raise ArgumentError, ":#{flag} is required" if foptions[:required]
+
+          next
+        end
+
+        # type cast (for boolean)
+        if foptions[:type] == :boolean
+          value = options[flag] = !!options[flag]
+        end
+
+        # type check
+        types = Array(foptions[:type])
+        raise ArgumentError, error_message(flag, value, types) if !valid?(value, types)
+      end
+
+      # return
+      options
+    end
+
+    protected
+
+    def defaults
+      flags.map { |flag, foptions| [flag, foptions[:default]] }.to_h.compact
+    end
+
+    # does value match valid?
+    def valid?(value, types)
+      types.any? do
+        case _1
+        when :array then true if value.is_a?(Array)
+        when :boolean then true # in Ruby everything is a boolean
+        when :float then true if value.is_a?(Float) || value.is_a?(Integer)
+        when :hash then true if value.is_a?(Hash)
+        when :integer then true if value.is_a?(Integer)
+        when :string then true if value.is_a?(String)
+        when :symbol then true if value.is_a?(Symbol)
+        when Class then true if value.is_a?(_1) # for custom checks
+        else
+          raise "unknown flag type #{_1.inspect}"
+        end
+      end
+    end
+
+    # nice error message for when value is invalid
+    def error_message(flag, value, valid)
+      classes = valid.compact.map do
+        s = _1.to_s
+        s = s.downcase if s =~ /\b(Array|Float|Hash|Integer|String|Symbol)\b/
+        s
+      end.join('/')
+      "expected :#{flag} to be #{classes}, not #{value.inspect}"
+    end
+  end
+end

data/lib/httpdisk/version.rb

@@ -1,3 +1,3 @@
 module HTTPDisk
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.5.2'.freeze
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: httpdisk
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Adam Doppelt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
+date: 2021-07-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: content-type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +84,7 @@ description: httpdisk works with faraday to aggressively cache responses on disk
 email: amd@gurge.com
 executables:
 - httpdisk
+- httpdisk-grep
 extensions: []
 extra_rdoc_files: []
 files:
@@ -82,16 +97,22 @@ files:
 - README.md
 - Rakefile
 - bin/httpdisk
+- bin/httpdisk-grep
 - examples.rb
 - httpdisk.gemspec
 - lib/httpdisk.rb
 - lib/httpdisk/cache.rb
 - lib/httpdisk/cache_key.rb
-- lib/httpdisk/cli.rb
-- lib/httpdisk/cli_slop.rb
+- lib/httpdisk/cli/args.rb
+- lib/httpdisk/cli/main.rb
 - lib/httpdisk/client.rb
 - lib/httpdisk/error.rb
+- lib/httpdisk/grep/args.rb
+- lib/httpdisk/grep/main.rb
+- lib/httpdisk/grep/printer.rb
 - lib/httpdisk/payload.rb
+- lib/httpdisk/slop_duration.rb
+- lib/httpdisk/sloptions.rb
 - lib/httpdisk/version.rb
 - logo.svg
 homepage: http://github.com/gurgeous/httpdisk

data/lib/httpdisk/cli.rb

@@ -1,223 +0,0 @@
-require 'faraday-cookie_jar'
-require 'faraday_middleware'
-require 'ostruct'
-
-module HTTPDisk
-  # Command line httpdisk command.
-  class Cli
-    attr_reader :options
-
-    # for --expires
-    UNITS = {
-      s: 1,
-      m: 60,
-      h: 60 * 60,
-      d: 24 * 60 * 60,
-      w: 7 * 24 * 60 * 60,
-      y: 365 * 7 * 24 * 60 * 60,
-    }.freeze
-
-    def initialize(options)
-      @options = options
-    end
-
-    # we have a very liberal retry policy
-    RETRY_OPTIONS = {
-      methods: %w[delete get head options patch post put trace],
-      retry_statuses: (400..600).to_a,
-      retry_if: ->(_env, _err) { true },
-    }.freeze
-
-    # Make the request (or print status)
-    def run
-      # short circuit --status
-      if options[:status]
-        status
-        return
-      end
-
-      # create Faraday client
-      faraday = create_faraday
-
-      # run request
-      response = faraday.run_request(request_method, request_url, request_body, request_headers)
-      if response.status >= 400
-        raise CliError, "the requested URL returned error: #{response.status} #{response.reason_phrase}"
-      end
-
-      # output
-      if options[:output]
-        File.open(options[:output], 'w') { output(response, _1) }
-      else
-        output(response, $stdout)
-      end
-    end
-
-    def create_faraday
-      Faraday.new do
-        # connection settings
-        _1.proxy = proxy if options[:proxy]
-        _1.options.timeout = options[:max_time] if options[:max_time]
-
-        # cookie middleware
-        _1.use :cookie_jar
-
-        # BEFORE httpdisk so each redirect segment is cached
-        _1.response :follow_redirects
-
-        # httpdisk
-        _1.use :httpdisk, client_options
-
-        # AFTER httpdisk so transient failures are not cached
-        if options[:retry]
-          _1.request :retry, RETRY_OPTIONS.merge(max: options[:retry])
-        end
-      end
-    end
-
-    # Support for --status
-    def status
-      # build env
-      env = Faraday::Env.new.tap do
-        _1.method = request_method
-        _1.request_body = request_body
-        _1.request_headers = request_headers
-        _1.url = request_url
-      end
-
-      # now print status
-      client = HTTPDisk::Client.new(nil, client_options)
-      client.status(env).each do
-        puts "#{_1}: #{_2.inspect}"
-      end
-    end
-
-    # Output response to f
-    def output(response, f)
-      if options[:include]
-        f.puts "HTTPDISK #{response.status} #{response.reason_phrase}"
-        response.headers.each { f.puts("#{_1}: #{_2}") }
-        f.puts
-      end
-      f.write(response.body)
-    end
-
-    #
-    # request_XXX
-    #
-
-    # HTTP method (get, post, etc.)
-    def request_method
-      method = if options[:request]
-        options[:request]
-      elsif options[:data]
-        'post'
-      end
-      method ||= 'get'
-      method = method.downcase.to_sym
-
-      if !Faraday::Connection::METHODS.include?(method)
-        raise CliError, "invalid --request #{method.inspect}"
-      end
-
-      method
-    end
-
-    # Request url
-    def request_url
-      url = options[:url]
-      # recover from missing http:
-      if url !~ %r{^https?://}i
-        if url =~ %r{^\w+://}
-          raise CliError, 'only http/https supported'
-        end
-
-        url = "http://#{url}"
-      end
-      URI.parse(url)
-    rescue URI::InvalidURIError
-      raise CliError, "invalid url #{url.inspect}"
-    end
-
-    # Request body
-    def request_body
-      options[:data]
-    end
-
-    # Request headers
-    def request_headers
-      {}.tap do |headers|
-        if options[:user_agent]
-          headers['User-Agent'] = options[:user_agent]
-        end
-
-        options[:header].each do |header|
-          key, value = header.split(': ', 2)
-          if !key || !value || key.empty? || value.empty?
-            raise CliError, "invalid --header #{header.inspect}"
-          end
-
-          headers[key] = value
-        end
-      end
-    end
-
-    #
-    # helpers
-    #
-
-    # Options to HTTPDisk::Client
-    def client_options
-      {}.tap do |client_options|
-        client_options[:dir] = options[:dir]
-        if options[:expires]
-          seconds = parse_expires(options[:expires])
-          if !seconds
-            raise CliError, "invalid --expires #{options[:expires].inspect}"
-          end
-
-          client_options[:expires_in] = seconds
-        end
-        client_options[:force] = options[:force]
-        client_options[:force_errors] = options[:force_errors]
-      end
-    end
-
-    # Return validated --proxy flag if present
-    def proxy
-      return if !options[:proxy]
-
-      proxy = parse_proxy(options[:proxy])
-      raise CliError, "--proxy should be host[:port], not #{options[:proxy].inspect}" if !proxy
-
-      proxy
-    end
-
-    # Parse --expires flag
-    def parse_expires(s)
-      m = s.match(/^(\d+)([smhdwy])?$/)
-      return if !m
-
-      num, unit = m[1].to_i, (m[2] || 's').to_sym
-      return if !UNITS.key?(unit)
-
-      num * UNITS[unit]
-    end
-
-    # Parse --proxy flag
-    def parse_proxy(proxy_flag)
-      host, port = proxy_flag.split(':', 2)
-      return if !host || host.empty?
-      return if port&.empty?
-
-      URI.parse('http://placeholder').tap do
-        begin
-          _1.host = host
-          _1.port = port if port
-        rescue URI::InvalidComponentError
-          return
-        end
-      end.to_s
-    end
-  end
-end