remocon 0.1.0

data/lib/remocon/command/push_command.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: false
+
+module Remocon
+  module Command
+    class Push
+      attr_reader :uri
+
+      def initialize(opts)
+        @opts = opts
+
+        @project_id = ENV.fetch('FIREBASE_PROJECT_ID')
+        @token = ENV.fetch('REMOTE_CONFIG_ACCESS_TOKEN')
+        @uri = URI.parse("https://firebaseremoteconfig.googleapis.com/v1/projects/#{@project_id}/remoteConfig")
+        @source_filepath = @opts[:source]
+        @etag = File.exist?(@opts[:etag]) ? File.open(@opts[:etag]).read : @opts[:etag] if @opts[:etag]
+        @ignore_etag = @opts[:force]
+        @dest_dir = File.join(@opts[:dest], @project_id) if @opts[:dest]
+
+        @cmd_opts = { validate_only: false }
+      end
+
+      def run
+        # to prevent a real request in spec
+        do_request
+      end
+
+      def client
+        return @client if @client
+
+        client = Net::HTTP.new(uri.host, uri.port)
+        client.use_ssl = true
+
+        @client = client
+      end
+
+      def request
+        return @request if @request
+
+        raise 'etag should be specified. If you want to ignore this error, then add --force option' unless @etag || @ignore_etag
+
+        headers = {
+          'Authorization' => "Bearer #{@token}",
+          'Content-Type' => 'application/json; UTF8'
+        }
+        headers['If-Match'] = @etag || '*'
+
+        request = Net::HTTP::Put.new(uri.request_uri, headers)
+        request.body = ""
+        request.body << File.read(@source_filepath).delete("\r\n")
+
+        @request = request
+      end
+
+      private
+
+      def do_request
+        response = client.request(request)
+
+        response_body = begin
+          json_str = response&.read_body
+          JSON.parse(json_str).with_indifferent_access if json_str
+        end
+
+        case response
+        when Net::HTTPOK
+          parse_success_body(response, response_body)
+          # intentional behavior
+          STDERR.puts 'Updated successfully.'
+        when Net::HTTPBadRequest
+          # sent json contains errors
+          parse_error_body(response, response_body) if response_body
+          STDERR.puts '400 but no error body' unless response_body
+        when Net::HTTPUnauthorized
+          # token was expired
+          STDERR.puts '401 Unauthorized. A token might be expired or invalid.'
+        when Net::HTTPForbidden
+          # remote config api might be disabled or not yet activated
+          STDERR.puts '403 Forbidden. RemoteConfig API might not be activated or be disabled.'
+        when Net::HTTPConflict
+          # local content is out-to-date
+          STDERR.puts '409 Conflict. Remote was updated. Please update your local files'
+        end
+      end
+
+      def parse_success_body(response, _success_body)
+        return unless etag = response.header["etag"]
+
+        if @dest_dir
+          File.open(File.join(@dest_dir, 'etag'), 'w+') do |f|
+            f.write(etag)
+            f.flush
+          end
+        else
+          STDOUT.puts etag
+        end
+      end
+
+      def parse_error_body(_response, error_body)
+        STDERR.puts "Error name : #{error_body[:error][:status]}"
+        STDERR.puts "Please check your json file"
+
+        error_body.dig(:error, :details)&.each do |k|
+          # for now, see only errors below
+          next unless k['@type'] == 'type.googleapis.com/google.rpc.BadRequest'
+
+          k[:fieldViolations].each do |e|
+            if e[:field].start_with?('remote_config.conditions')
+              STDERR.puts 'CONDITION DEFINITION ERROR'
+            else
+              STDERR.puts 'PARAMETER DEFINITION ERROR'
+            end
+
+            STDERR.puts e[:description]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/remocon/command/validate_command.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Remocon
+  module Command
+    class Validate
+      include Remocon::InterpreterHelper
+
+      def initialize(opts)
+        @opts = opts
+
+        @conditions_filepath = @opts[:conditions]
+        @parameters_filepath = @opts[:parameters]
+
+        @cmd_opts = { validate_only: true }
+      end
+
+      def run
+        validate_options
+
+        if parameter_errors.empty? && condition_errors.empty?
+          STDOUT.puts 'No error was found.'
+        else
+          (parameter_errors + condition_errors).each do |e|
+            STDERR.puts "#{e.class} #{e.message}"
+            STDERR.puts e.backtrace.join("\n")
+          end
+        end
+      end
+
+      private
+
+      def validate_options
+        raise ValidationError, 'A condition file must exist' unless File.exist?(@conditions_filepath)
+        raise ValidationError, 'A parameter file must exist' unless File.exist?(@parameters_filepath)
+      end
+    end
+  end
+end

data/lib/remocon/dumper/condition_file_dumper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Remocon
+  class ConditionFileDumper
+    def initialize(conditions)
+      @conditions = conditions
+    end
+
+    def dump
+      # use as it is
+      @conditions
+    end
+  end
+end

data/lib/remocon/dumper/parameter_file_dumper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Remocon
+  class ParameterFileDumper
+    def initialize(parameters)
+      @parameters = parameters.with_indifferent_access
+    end
+
+    def dump
+      @parameters.each_with_object({}) do |(key, body), hash|
+        hash[key] = body[:defaultValue]
+        hash[key][:description] = body[:description] if body[:description]
+
+        next unless body[:conditionalValues]
+
+        hash[key][:conditions] = body[:conditionalValues].each_with_object({}) do |(key2, body2), hash2|
+          hash2[key2] = body2
+        end
+      end
+    end
+  end
+end

data/lib/remocon/error/unsupported_type_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Remocon
+  class UnsupportedTypeError < StandardError
+    def initialize(type)
+      super "#{type} is not supported as type"
+    end
+  end
+end

data/lib/remocon/error/validation_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Remocon
+  class ValidationError < StandardError; end
+
+  class EmptyNameError < ValidationError; end
+  class EmptyExpressionError < ValidationError; end
+  class DuplicateKeyError < ValidationError; end
+  class NotFoundConditionKey < ValidationError; end
+end

data/lib/remocon/interpreter/condition_file_interpreter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Remocon
+  class ConditionFileInterpreter
+    SUPPORTED_ATTRIBUTED = %i[name expression tagColor]
+
+    def initialize(filepath)
+      # conditions should be Array
+      @yaml = YAML.safe_load(File.open(filepath).read).map(&:with_indifferent_access)
+    end
+
+    def read(opts = {})
+      errors = []
+      json_array = @yaml.dup
+
+      keys = []
+
+      @yaml.each do |hash|
+        raise Remocon::EmptyNameError, 'name must not be empty' unless hash[:name]
+        raise Remocon::EmptyExpressionError, 'expression must not be empty' unless hash[:expression]
+        raise Remocon::DuplicateKeyError, "#{hash[:name]} is duplicated" if keys.include?(hash[:name])
+
+        keys.push(hash[:name])
+      rescue Remocon::ValidationError => e
+        raise e unless opts[:validate_only]
+        errors.push(e)
+      end
+
+      [json_array, errors]
+    end
+  end
+end

data/lib/remocon/interpreter/parameter_file_interpreter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Remocon
+  class ParameterFileInterpreter
+    def initialize(filepath)
+      @yaml = YAML.safe_load(File.open(filepath).read).with_indifferent_access
+    end
+
+    def read(condition_names, opts = {})
+      errors = []
+      json_hash = @yaml.each_with_object({}) do |(key, body), hash|
+        raise Remocon::DuplicateKeyError, "#{key} is duplicated" if hash[key]
+
+        hash[key] = {
+          defaultValue: {
+            value: parse_value_body(key, body)
+          }
+        }
+
+        hash[key][:conditionalValues] = parse_condition_body(condition_names, key, body[:conditions]) if body[:conditions]
+        hash[key][:description] = body[:description] if body[:description]
+      rescue Remocon::ValidationError => e
+        raise e unless opts[:validate_only]
+        errors.push(e)
+      end
+
+      [json_hash.with_indifferent_access, errors]
+    end
+
+    private
+
+    def read_value(body)
+      body[:file] ? File.open(body[:file]).read : body[:value]
+    end
+
+    def parse_value_body(key, value_body)
+      case value_body
+      when Hash
+        value = read_value(value_body)
+        options = { key: key }.merge(value_body[:options] || {})
+        normalizer = TypeNormalizerFactory.get(value_body[:normalizer]).new(value, options)
+        normalizer.process
+        normalizer.content
+      else # includes Array
+        # use raw value
+        value_body
+      end
+    end
+
+    def parse_condition_body(condition_names, key, condition_body)
+      condition_body.each_with_object({}) do |(cond_key, body), hash|
+        raise Remocon::NotFoundConditionKey, "The condition '#{cond_key}' is not defined" unless condition_names.include?(cond_key.to_s)
+
+        hash[cond_key] = {
+          value: parse_value_body(key, body)
+        }
+      end
+    end
+  end
+end

data/lib/remocon/normalizer/boolean_normalizer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Remocon
+  class BooleanNormalizer < Remocon::Normalizer
+    def self.respond_symbol
+      Remocon::Type::BOOLEAN
+    end
+
+    def validate
+      return if [FalseClass, TrueClass].include?(@content.class)
+
+      begin
+        @bool_val = @content.to_s.to_boolean
+      rescue ArgumentError => e
+        raise ValidationError, e.message
+      end
+    end
+
+    def normalize
+      @bool_val
+    end
+  end
+end

data/lib/remocon/normalizer/integer_normalizer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Remocon
+  class IntegerNormalizer < Remocon::Normalizer
+    def self.respond_symbol
+      Remocon::Type::INTEGER
+    end
+
+    def validate
+      return if @content.class == Integer.class
+
+      begin
+        @int_val = @content.to_s.to_integer
+      rescue ArgumentError => e
+        raise ValidationError, e.message
+      end
+    end
+
+    def normalize
+      @int_val
+    end
+  end
+end

data/lib/remocon/normalizer/json_normalizer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Remocon
+  class JsonNormalizer < Remocon::Normalizer
+    def self.respond_symbol
+      Remocon::Type::JSON
+    end
+
+    def validate
+      str_content = @content.is_a?(Hash) ? @content.to_json : @content.to_s
+      @json = JSON.parse(str_content).to_json
+    rescue JSON::ParserError => e
+      raise ValidationError, e.message
+    end
+
+    def normalize
+      @json
+    end
+  end
+end

data/lib/remocon/normalizer/normalizer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Remocon
+  class Normalizer
+    attr_reader :content
+
+    def initialize(content, opts)
+      @content = content.nil? ? opts[:default] : content
+      @opts = opts
+    end
+
+    def process
+      tap do
+        raise Remocon::ValidationError, "#{self.class} is not satisfying normalizer" unless self.class.respond_symbol
+
+        validate
+        @content = normalize
+      end
+    end
+
+    def validate
+      # no-op
+    end
+
+    def normalize
+      @content
+    end
+
+    def self.respond_symbol
+      raise Remocon::UnsupportedTypeError, 'unknown'
+    end
+  end
+end

data/lib/remocon/normalizer/string_normalizer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Remocon
+  class StringNormalizer < Remocon::Normalizer
+    def self.respond_symbol
+      Remocon::Type::STRING
+    end
+
+    def normalize
+      @content&.to_s
+    end
+  end
+end

data/lib/remocon/normalizer/type_normalizer_factory.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Remocon
+  class TypeNormalizerFactory
+    include Singleton
+
+    def self.register(normalizer_klass)
+      raise "#{normalizer_klass} must inherit #{Remocon::Normalizer}" unless normalizer_klass < Remocon::Normalizer
+      instance.plugin_map[normalizer_klass.respond_symbol] = normalizer_klass
+    end
+
+    def self.get(normalizer_sym)
+      instance.plugin_map[normalizer_sym&.to_sym || Remocon::Type::VOID]
+    end
+
+    def plugin_map
+      return @plugin_map if @plugin_map
+      @plugin_map = {}
+
+      Remocon::Normalizer.subclasses.each { |klass| Remocon::TypeNormalizerFactory.register(klass) }
+
+      @plugin_map
+    end
+  end
+end