fuelator 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c314ddfd359418f28022afc3df15e9688603c883
-  data.tar.gz: c3a5d09cd173a92ccffcf8a7e3927f7248402ce3
+  metadata.gz: 52e3da363267f184f76cf719b684b5422d3dcfca
+  data.tar.gz: 270e68d051d6a2a98023c091dbc78d72d082ac95
 SHA512:
-  metadata.gz: a987cd56b626b3582ccd98c226b6f1adef527bb3f906208f58825ee9c984faac117f7c83868d35458e85da6a4afcc3cb1184950ad56dd6d7d0391493ffd55e7d
-  data.tar.gz: 9e9bed5265ebb27efa4e81ebfeb2a5f08a9089f8e1863a862092009d285cdbc46631db784e050f8440bd2ec2a8c1d271410b44ce12aaeda7ff7978aab202e694
+  metadata.gz: 3e47ac42223a6c2d6b2990f0259b93dcd637f60369e655511f85a85fb58de3b2e24d98139cf078ed268813c1c94cb147ed166497004c2c63af667ddcee0a1d72
+  data.tar.gz: cfe0164fce7608eab69c010312e16bfeb308aa7870eb031060c5bc1b71e2e5968b0c6c87d981a9d9c49162b0da0fe236bc4646c51afaea454458d4c40d8f76d8

data/Gemfile

@@ -5,4 +5,4 @@ gemspec
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
-gem 'pry'
+gem 'pry'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fuelator.rb (0.1.0)
+    fuelator (0.1.8)
 
 GEM
   remote: https://rubygems.org/
@@ -31,7 +31,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  fuelator.rb!
+  fuelator!
   pry
   rake (~> 12.0)
   rspec (~> 3.0)

data/README.md

@@ -24,6 +24,18 @@ If you plan a trip to Moon, once you are at fuel station, run:
 
     $ fuelator  28801, [[:launch, 9.807], [:land, 1.62], [:launch, 1.62], [:land, 9.807]] 
 
+Or use API provided:
+```ruby
+require 'fuelator'
+
+Fuelator.calculate(28801, [[:launch, 9.807], [:land, 1.62], [:launch, 1.62], [:land, 9.807]])
+# => 51898
+```
+Be ready do handle errors:
+```ruby
+Fuelator::Parameters::Error
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/fuelator

@@ -1,43 +1,85 @@
 #!/usr/bin/env ruby
 
 require "fuelator"
-require 'optionparser'
+require 'optparse'
 
-def log(object)
-  STDERR.puts object
-end
+class OptsParser
+  Version = Fuelator::VERSION
+
+  class Options
+    attr_accessor :verbose, :mass, :pairs
 
-verbose = false
+    def initialize
+      @verbose = false
+      @mass    = 0
+      @pairs   = []
+    end
+  end
 
-optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: fuelator [args]"
+  def self.parse
+    @options = Options.new
+    parser.parse!
+    @options
+  end
 
-  opts.separator "Args sample: 28801 launch 9.807 land 1.62 launch 1.62 land 9.807"
-  opts.separator "Where 28801 - flight ship mass"
-  opts.separator "directive/gravity pairs:"
-  opts.separator "      launch - flight directive"
-  opts.separator "      1.62 -  target planet gravity"
-  opts.separator "Add as many directive/gravity pairs as you wish. Note, you can not pass 2 same directives in a sequence."
+  def self.parser
+    @parser ||= OptionParser.new do |parser|
+      parser.banner = "Usage: fuelator [options]"
+      parser.separator ""
+      parser.separator "Specific options:"
 
-  opts.on("-v", "--verbose", "Verbose mode") do |v|
-    verbose = v
+      boolean_verbose_option parser
+      float_mass_option(parser)
+      list_pairs_option(parser)
+
+      parser.separator ""
+      parser.separator "Common options:"
+      # No argument, shows at tail. This will print an options summary.
+      # Try it and see!
+      parser.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
+      # Another typical switch to print the version.
+      parser.on_tail("--version", "Show version") do
+        puts Version
+        exit
+      end
+    end
+  end
+
+  def self.boolean_verbose_option(parser)
+    # Boolean switch.
+    parser.on("-v", "--[no-]verbose", "Show error backtrace") do |v|
+      @options.verbose = v
+    end
+  end
+
+  def self.float_mass_option(parser)
+    # Mass required float option.
+    parser.on("-m", "--mass MASS", Float, "Space ship mass") do |v|
+      @options.mass = v
+    end
+  end
+
+  def self.list_pairs_option(parser)
+    # List of arguments.
+    parser.on("-p", "--pair PAIRS", Array, "Directive/gravity comma separated pairs: -p launch,9.2 -p land,2.2") do |list|
+      list = list.map { |v| (!!Float(v) rescue false) ? v.to_f : v.to_sym }
+      @options.pairs << list
+    end
   end
-end
-optparse.parse!
-
-def run(params, verbose)
-  result = Fuelator.calculate(params)
-  log "#{result.to_i} kg"
-rescue Fuelator::Error, Fuelator::Parameters::Error => e
-  log_error(e, verbose)
-rescue StandardError => e
-  log_error(e, verbose)
 end
 
-def log_error(e, verbose)
-  log e
-  log e.backtrace if verbose
-  false
+def run_script
+  options = OptsParser.parse
+  begin
+    puts "#{Fuelator::Calc.new(options.mass, options.pairs).run} kg"
+  rescue Fuelator::Parameters::Error, StandardError => e
+    puts e
+    puts e.backtrace if options.verbose
+  end
 end
 
-exit 1 unless run ARGV, verbose
+ARGV << '-h' if ARGV.empty?
+run_script

data/lib/fuelator.rb

@@ -1,56 +1,8 @@
 require "fuelator/version"
+require 'fuelator/parameters/validator'
+require 'fuelator/parameters/pair'
 require "fuelator/parameters"
-# Calculation of fuel required for flight based on input params
+require "fuelator/calc"
 
 module Fuelator
-  # Calculate fuel for a flight
-  #
-  # Example:
-  #   >> Fuelator.calculate(28801, [[:launch, 9.807], [:land, 1.62], [:launch, 1.62], [:land, 9.807]])
-  #   => 51898
-
-  class Error < StandardError; end
-
-  FLIGHT_CONSTANTS = {
-    launch: {
-      theta: 0.042,
-      bias:  33,
-    },
-    land:   {
-      theta: 0.033,
-      bias:  42,
-    },
-  }
-
-  # @param [Array] params
-  #  [123, [[:launch, 123]]] or flatten [123, :launch, 123]
-  # params are validated and validation error may be raised
-  # @return Float - fuel for a flight
-  def self.calculate(*params)
-    parameters = Parameters.new(params)
-
-    full_mass = parameters.mass
-
-    parameters.dir_grav_pairs.reverse.map do |val|
-      full_mass += recursive_calculate(full_mass, val)
-    end.last - parameters.mass
-  end
-
-  private
-
-  def self.recursive_calculate(mass, params)
-    directive = params[0]
-    gravity   = params[1]
-    constants = FLIGHT_CONSTANTS[directive]
-
-    begin
-      fuel_mass = (mass * gravity * constants[:theta] - constants[:bias]).to_i # rounded down
-    rescue StandardError => e
-      raise Error.new(e.message)
-    end
-
-    return 0 if fuel_mass <= 0
-    result = recursive_calculate(fuel_mass, params)
-    fuel_mass + result
-  end
 end

data/lib/fuelator/calc.rb

@@ -0,0 +1,46 @@
+# Calculation of fuel required for flight based on input params
+
+module Fuelator
+  # Calculate fuel for a flight
+  #
+  # Example:
+  #   >> Fuelator.Calc.new(28801, [[:launch, 9.807], [:land, 1.62], [:launch, 1.62], [:land, 9.807]]).run
+  #   => 51898
+  class Calc
+    attr_reader :parameters
+
+    FLIGHT_CONSTANTS = {
+      launch: {
+        theta: 0.042,
+        bias:  33,
+      },
+      land:   {
+        theta: 0.033,
+        bias:  42,
+      },
+    }
+
+    def initialize(mass, pairs)
+      @parameters = Parameters.new(mass, pairs)
+    end
+
+    def run
+      full_mass = parameters.mass
+
+      parameters.reversed.map do |val|
+        full_mass += recursive_calculate(full_mass, val)
+      end.last - parameters.mass
+    end
+
+    private
+
+    def recursive_calculate(mass, pair)
+      constants = FLIGHT_CONSTANTS[pair.directive]
+      fuel_mass = (mass * pair.gravity * constants[:theta] - constants[:bias]).to_i # rounded down
+
+      return 0 if fuel_mass <= 0
+      result = recursive_calculate(fuel_mass, pair)
+      fuel_mass + result
+    end
+  end
+end

data/lib/fuelator/parameters.rb

@@ -1,41 +1,48 @@
-require 'fuelator/parameters/error'
 # For flight parameters validation purposes
 
 module Fuelator
   class Parameters
-    attr_reader :mass, :dir_grav_pairs
+    include Validator
 
-    def initialize(params)
-      params          = normalize(params)
-      @mass           = params[0]
-      @dir_grav_pairs = params[1..-1].each_slice(2).to_a
+    class Error < StandardError; end
+
+    attr_reader :mass, :pairs, :order
+
+    def initialize(mass, pairs)
+      @mass  = mass
+      @pairs = pairs.map { |pair| Pair.new(pair) }
+      @order = define_order
 
       validate!
     end
 
+    def reversed
+      pairs.reverse
+    end
+
     private
 
-    def normalize(params)
-      params.flatten.map { |v| (!!Float(v) rescue false) ? v.to_f : v.to_sym }
+    def valid_mass?
+      !mass.nil? && mass.is_a?(Numeric)
     end
 
-    def validate!
-      error(:mass, mass) unless mass.is_a?(Float)
-      validate_pairs!
+    def valid_pairs?
+      !pairs.empty?
     end
 
-    def validate_pairs!
-      dir = nil
-      dir_grav_pairs.each do |pair|
-        error(:pairs, pair.count) if (pair.count % 2) != 0
-        error(:format, pair[0], pair[1]) unless pair[0].is_a?(Symbol) && pair[1].is_a?(Float)
-        error(:sequence, dir, pair[0]) if dir == pair[0] # no same directives allowed in a sequence
-        dir = pair[0]
-      end
+    def valid_order?
+      !order
     end
 
-    def error(type, *args)
-      raise Error.new Error::MESSAGES[type] % args
+    # you can only calculate if directives passed in right order - :launch->:land
+    def define_order
+      dir = nil
+      pairs.map do |pair|
+        return true if dir == pair.directive
+
+        dir = pair.directive
+      end
+      false
     end
   end
 end

data/lib/fuelator/parameters/pair.rb

@@ -0,0 +1,25 @@
+module Fuelator
+  class Parameters
+    class Pair
+      include Validator
+      DIRECTIVES = [:launch, :land]
+
+      attr_reader :directive, :gravity
+
+      def initialize(pair)
+        @directive = pair[0]
+        @gravity   = pair[1]
+
+        validate!
+      end
+
+      def valid_directive?
+        DIRECTIVES.include?(directive) && directive.is_a?(Symbol)
+      end
+
+      def valid_gravity?
+        !gravity.nil? && gravity.is_a?(Numeric)
+      end
+    end
+  end
+end

data/lib/fuelator/parameters/validator.rb

@@ -0,0 +1,15 @@
+module Fuelator
+  class Parameters
+    module Validator
+
+      # runs #valid_[variable]? method for every instance variable
+      # raises Error defined in parent namespace
+      def validate!
+        instance_variables.each do |v|
+          v_name = v.to_s.gsub(/^@/, '')
+          raise Error.new("value for #{v_name} is invalid") unless send("valid_#{v_name}?")
+        end
+      end
+    end
+  end
+end

data/lib/fuelator/version.rb

@@ -1,3 +1,3 @@
 module Fuelator
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fuelator
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Sergii Brytiuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-24 00:00:00.000000000 Z
+date: 2020-07-26 00:00:00.000000000 Z
 dependencies: []
 description: |-
   The goal of this application is to calculate fuel
@@ -37,8 +37,10 @@ files:
 - bin/setup
 - fuelator.gemspec
 - lib/fuelator.rb
+- lib/fuelator/calc.rb
 - lib/fuelator/parameters.rb
-- lib/fuelator/parameters/error.rb
+- lib/fuelator/parameters/pair.rb
+- lib/fuelator/parameters/validator.rb
 - lib/fuelator/version.rb
 homepage: https://github.com/645383/fuelator
 licenses:

data/lib/fuelator/parameters/error.rb

@@ -1,15 +0,0 @@
-# Flight parameters validation error,
-# Add error descriptive message to map of messages when new validation case added
-
-module Fuelator
-  class Parameters
-    class Error < StandardError
-      MESSAGES = {
-        format: "directive/gravity pairs should be in format string/float: directive: %s, gravity: %s",
-        sequence: "you can not pass 2 same directives in a sequence: %s => %s",
-        mass: "mass should be float: %s",
-        pairs: "provide pairs for directive/gravity: %s elements"
-      }
-    end
-  end
-end