release_feature 0.1.0

data/lib/release_feature/client.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ReleaseFeature
+  class Client
+    attr_reader :updated_at
+
+    # @param [String, Symbol] environment
+    # @param [ActiveRecordRepository, YamlRecordRepository, HashRecordRepository] base_repository
+    # @param [nil] extra_repository
+    # @param [Integer] refresh_interval_sec
+    def initialize(environment:, base_repository:, extra_repository: nil, refresh_interval_sec: 600)
+      @environment = environment.to_sym
+      @base_repository = base_repository
+      @extra_repository = extra_repository
+      @refresh_interval_sec = if refresh_interval_sec.is_a?(Integer)
+                                refresh_interval_sec
+                              else
+                                raise ReleaseFeature::Error, 'refresh_interval_sec must be Integer'
+                              end
+      load_features
+    end
+
+    # @param [Symbol] feature_name
+    # @param [TrueClass, FalseClass] time
+    def permitted?(feature_name, time: nil)
+      time ||= Time.now
+
+      refresh if expired?(time)
+
+      name = feature_name.to_sym
+      raise ReleaseFeature::Error, "#{feature_name} is not registered." if @features[feature_name.to_sym].nil?
+
+      feature = to_feature(@features, name, @environment)
+      return false if feature.nil?
+
+      feature.permitted?(time)
+    end
+
+    def current_features
+      @features
+    end
+
+    def refresh
+      load_features
+      true
+    rescue StandardError => e
+      e.message
+      # errorがある場合は@featuresを更新しない
+      false
+    end
+
+    def names
+      @features.names
+    end
+
+    def environments
+      @features.environments
+    end
+
+    private
+
+    def to_feature(features, name, environment)
+      features.dig(name, environment)
+    end
+
+    def expired?(time = nil)
+      time ||= Time.now
+      raise ReleaseFeature::Error, 'current_time is must be Time class' unless time.is_a?(Time)
+
+      @updated_at + @refresh_interval_sec < time
+    end
+
+    def load_features
+      features = if @extra_repository
+                   @base_repository.features.combine_features(@extra_repository.features)
+                 else
+                   @base_repository.features
+                 end
+      @features = features
+      @updated_at = Time.now
+    end
+  end
+end

data/lib/release_feature/example/config.yml

@@ -0,0 +1,20 @@
+timezone: JST
+features:
+  hoge_feature:
+    development:
+      open_at: 2000-01-01 00:00
+      close_at: 2999-12-31 23:59
+    staging:
+      open_at: 2021-11-01 10:00
+      close_at: 2999-12-31 23:59
+    production:
+      open_at: 2021-12-01 10:00
+      close_at: 2999-12-31 23:59
+  puyo_feature:
+    development:
+      open_at: 2000-01-01 00:00
+      close_at: 2999-12-31 23:59
+    production:
+      open_at: 2022-12-01 10:00
+      close_at: 2999-12-31 23:59
+

data/lib/release_feature/feature.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ReleaseFeature
+  class Feature
+    attr_reader :name, :environment, :open_at, :close_at, :errors
+
+    # @param [String, Symbol] name
+    # @param [String, Symbol] environment
+    # @param [Time] open_at
+    # @param [Time] close_at
+    def initialize(name:, environment:, open_at:, close_at:)
+      validate_present({ name: name, environment: environment, open_at: open_at, close_at: close_at })
+      @name = cast_to_sym(:name, name)
+      @environment = cast_to_sym(:environment, environment)
+      @open_at = open_at
+      @close_at = close_at
+      raise ReleaseFeature::Error, errors_full_message unless valid?
+    end
+
+    # @param [Time] current_time
+    # @return [TrueClass, FalseClass]
+    def permitted?(current_time)
+      (open_at...close_at).cover?(current_time)
+    end
+
+    private
+
+    # @return [TrueClass, FalseClass]
+    def valid?
+      initialize_errors
+      validate_all
+      @errors.size.zero?
+    end
+
+    def validate_present(attrs)
+      attrs.each do |k, v|
+        if v.nil?
+          raise ReleaseFeature::Error,
+                "#{k} must be present."
+        end
+      end
+    end
+
+    def validate_all
+      validate_name
+      validate_open_at
+      validate_close_at
+      validate_range
+    end
+
+    def errors_full_message
+      @errors.join(' ')
+    end
+
+    def initialize_errors
+      @errors = []
+    end
+
+    # @param [String, Symbol] attr_name
+    # @param [Object] val
+    # @param [String] message
+    def add_error(attr_name, val, message)
+      @errors << "#{val} of #{attr_name} has error. #{message}"
+    end
+
+    def validate_name
+      message = name_error_message(name)
+      return unless message
+
+      add_error('name', name, message)
+    end
+
+    def validate_open_at
+      return if time_present?(open_at)
+
+      add_error('open_at', open_at, 'set time to open_at.')
+    end
+
+    def validate_close_at
+      return if time_present?(close_at)
+
+      add_error('close_at', close_at, 'set time to close_at.')
+    end
+
+    def validate_range
+      return if open_at < close_at
+
+      add_error('open_at', open_at, 'open_at is less than close_at.')
+      add_error('close_at', close_at, 'close_at is more than open_at.')
+    end
+
+    # @param [String] attr
+    def time_present?(attr)
+      attr.is_a?(Time)
+    end
+
+    # @param [Symbol] key
+    # @param [String, Symbol] str
+    def cast_to_sym(key, str)
+      raise ReleaseFeature::Error, "#{key} must be String or Symbol" unless str.is_a?(String) || str.is_a?(Symbol)
+
+      str.to_sym
+    end
+
+    # @param [String, Symbol] name
+    # @return [String, NilClass]
+    def name_error_message(name)
+      if name.to_s.match?(/\s/)
+        'space is not permitted to name.'
+      elsif name.to_s.size < 8
+        'more than 7 character is permitted to name.'
+      elsif !name.to_s.match?(/^[a-z]([a-z0-9_]{7,})$/)
+        ' 0-9 or a-z or _ is permitted to name.'
+      end
+    end
+  end
+end

data/lib/release_feature/feature_collection.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ReleaseFeature
+  class FeatureCollection < Hash
+    # @param [ReleaseFeature::FeatureCollection] features
+    # @return [ReleaseFeature::FeatureCollection]
+    def combine_features(features)
+      all_names = (names + features.names).uniq
+      all_environments = (environments + features.environments).uniq
+      all_names.each_with_object(ReleaseFeature::FeatureCollection.new).each do |name, memo_obj|
+        memo_obj[name] = build_environments(name, all_environments, features)
+      end
+    end
+
+    # @return [Array<Symbol>]
+    def names
+      keys
+    end
+
+    # @return [Array<Symbol>]
+    def environments
+      values.each_with_object([]) { |a, memo| memo.concat(a.keys) }.uniq
+    end
+
+    private
+
+    # @param [:Symbol] name
+    # @param [:Symbol] environments
+    # @param [ReleaseFeature::FeatureCollection] features
+    # @return [Hash{Symbol->Hash}]
+    def build_environments(name, environments, features)
+      environments.each_with_object({}) do |environment, memo_obj|
+        next unless build_feature(name, environment, features)
+
+        memo_obj[environment] = build_feature(name, environment, features)
+      end
+    end
+
+    # @param [:Symbol] name
+    # @param [:Symbol] environments
+    # @param [ReleaseFeature::FeatureCollection] features
+    # @return [ReleaseFeature::Feature]
+    def build_feature(name, environment, features)
+      if features.dig(name, environment)
+        features.dig(name, environment)
+      elsif dig(name, environment)
+        dig(name, environment)
+      end
+    end
+  end
+end

data/lib/release_feature/repository/active_record_repository.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ReleaseFeature
+  module Repository
+    class ActiveRecordRepository
+      # @param [Class] model
+      def initialize(model:)
+        @model = model
+      end
+
+      # @return [ReleaseFeature::FeatureCollection]
+      def features
+        data = @model.all
+        convert_to_feature_collection(data)
+      end
+
+      private
+
+      # @param [ActiveRecord] data
+      # @return [ReleaseFeature::FeatureCollection]
+      def convert_to_feature_collection(data)
+        data.each_with_object(ReleaseFeature::FeatureCollection.new) do |record, memo_obj|
+          name_key = record.name.to_sym
+          environment_key = record.environment.to_sym
+          feature = build_feature(record)
+          if memo_obj[name_key].nil?
+            memo_obj[name_key] = { environment_key => feature }
+          else
+            memo_obj[name_key][environment_key] = feature
+          end
+        end
+      end
+
+      # @param [ActiveRecord] record
+      # @return [ReleaseFeature::Feature]
+      def build_feature(record)
+        ReleaseFeature::Feature.new(
+          name: record.name,
+          environment: record.environment,
+          open_at: record.open_at,
+          close_at: record.close_at
+        )
+      end
+    end
+  end
+end

data/lib/release_feature/repository/hash_repository.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ReleaseFeature
+  module Repository
+    class HashRepository
+      # @param [Hash] hash
+      def initialize(hash:)
+        @hash = hash
+      end
+
+      # @return [ReleaseFeature::FeatureCollection]
+      def features
+        data = @hash
+        convert_to_feature_collection(data)
+      end
+
+      private
+
+      # @param [Hash] data
+      # @return [ReleaseFeature::FeatureCollection]
+      def convert_to_feature_collection(data)
+        data[:features].each_with_object(ReleaseFeature::FeatureCollection.new) do |(name, environments), memo_obj|
+          memo_obj[name] = {}
+          environments.each do |environment, range|
+            memo_obj[name][environment] = build_feature(name, environment, range[:open_at], range[:close_at])
+          end
+        end
+      end
+
+      # @param [Symbol] name
+      # @param [Symbol] environment
+      # @param [Time] open_at
+      # @param [Time] close_at
+      # @return [ReleaseFeature::Feature]
+      def build_feature(name, environment, open_at, close_at)
+        ReleaseFeature::Feature.new(
+          name: name,
+          environment: environment,
+          open_at: open_at,
+          close_at: close_at
+        )
+      end
+    end
+  end
+end

data/lib/release_feature/repository/yaml_repository.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'tzinfo'
+module ReleaseFeature
+  module Repository
+    class YamlRepository
+      class AccessibleRange
+        attr_reader :open_at, :close_at
+
+        def initialize(open_at:, close_at:)
+          @open_at = open_at
+          @close_at = close_at
+        end
+      end
+
+      # @param [String] path
+      def initialize(path:)
+        @path = path
+      end
+
+      # @return [ReleaseFeature::FeatureCollection]
+      def features
+        data = YAML.load_file(@path)
+        convert_to_feature_collection(data)
+      end
+
+      private
+
+      # @param [Hash] data
+      # @return [ReleaseFeature::FeatureCollection]
+      def convert_to_feature_collection(data)
+        timezone = data['timezone']
+        features = data['features']
+        symbolize_features(features, timezone)
+      end
+
+      # @param [Hash] features
+      # @return [ReleaseFeature::FeatureCollection]
+      def symbolize_features(features, timezone)
+        features.each_with_object(ReleaseFeature::FeatureCollection.new) do |(name, environments), memo_obj|
+          environments.each do |environment, range|
+            if memo_obj[name.to_sym]
+              memo_obj[name.to_sym][environment.to_sym] = build_feature(name, environment, range, timezone)
+            else
+              memo_obj[name.to_sym] = { environment.to_sym => build_feature(name, environment, range, timezone) }
+            end
+          end
+        end
+      end
+
+      # @param [Str] name
+      # @param [Str] environment
+      # @param [Hash] range
+      # @param [String] timezone
+      # @return [ReleaseFeature::Feature]
+      def build_feature(name, environment, range, timezone)
+        accessible_range = to_range_struct(range, timezone)
+        ReleaseFeature::Feature.new(
+          name: name.to_sym,
+          environment: environment.to_sym,
+          open_at: accessible_range.open_at,
+          close_at: accessible_range.close_at
+        )
+      end
+
+      # @param [Hash] range
+      # @param [String] timezone
+      # @return [AccessibleRange]
+      def to_range_struct(range, timezone)
+        AccessibleRange.new(
+          open_at: cast_to_time(range['open_at'], timezone),
+          close_at: cast_to_time(range['close_at'], timezone)
+        )
+      end
+
+      # @param [String] str
+      # @param [String] timezone
+      # @return [Time]
+      def cast_to_time(str, timezone)
+        time = Time.parse(str)
+        year = time.year
+        month = time.month
+        day = time.day
+        hour = time.hour
+        minute = time.min
+        Time.new(year, month, day, hour, minute, 0, timezone)
+      end
+    end
+  end
+end

data/lib/release_feature/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ReleaseFeature
+  VERSION = '0.1.0'
+end

data/lib/release_feature.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'yaml'
+require_relative 'release_feature/version'
+require_relative 'release_feature/repository/yaml_repository'
+require_relative 'release_feature/repository/active_record_repository'
+require_relative 'release_feature/repository/hash_repository'
+require_relative 'release_feature/feature'
+require_relative 'release_feature/client'
+require_relative 'release_feature/feature_collection'
+
+module ReleaseFeature
+  class Error < StandardError; end
+end

data/rbs_collection.lock.yaml

@@ -0,0 +1,104 @@
+---
+sources:
+- name: ruby/gem_rbs_collection
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  revision: main
+  repo_dir: gems
+path: ".gem_rbs_collection"
+gems:
+- name: date
+  version: '0'
+  source:
+    type: stdlib
+- name: time
+  version: '0'
+  source:
+    type: stdlib
+- name: activerecord
+  version: '6.1'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: activemodel
+  version: '6.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: activesupport
+  version: '6.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: listen
+  version: '3.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: parallel
+  version: '1.20'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 5e006c8976e661f16b61ba9193acce07f82b4ec5
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: yaml
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: singleton
+  version: '0'
+  source:
+    type: stdlib
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: mutex_m
+  version: '0'
+  source:
+    type: stdlib
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib
+- name: dbm
+  version: '0'
+  source:
+    type: stdlib
+- name: pstore
+  version: '0'
+  source:
+    type: stdlib

data/rbs_collection.yaml

@@ -0,0 +1,18 @@
+# Download sources
+sources:
+  - name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: rbs
+    ignore: true
+  - name: date
+  - name: time
+  - name: activerecord

data/release_feature.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'lib/release_feature/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'release_feature'
+  spec.version       = ReleaseFeature::VERSION
+  spec.authors       = ['junara']
+  spec.email         = ['jun5araki@gmail.com']
+
+  spec.summary       = 'Release feature in custom date range.'
+  spec.description   = 'Release feature in custom date range.'
+  spec.homepage      = 'https://github.com/junara/release_feature'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = 'https://github.com/junara/release_feature/blob/main/CHANGELOG.md'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'activerecord'
+  spec.add_development_dependency 'factory_bot'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-parameterized'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'timecop'
+  spec.add_dependency 'time'
+  spec.add_dependency 'yaml'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/sig/lib/release_feature/client.rbs

@@ -0,0 +1,31 @@
+module ReleaseFeature
+  class Client
+    @environment: Symbol
+    @base_repository: Repository::YamlRepository | Repository::HashRepository | Repository::ActiveRecordRepository
+    @extra_repository: untyped | Repository::YamlRepository | Repository::HashRepository | Repository::ActiveRecordRepository
+    @refresh_interval_sec: Integer
+    @features: FeatureCollection
+
+    attr_reader updated_at: Time
+
+    def initialize: (environment: String | Symbol, base_repository: Repository::YamlRepository | Repository::HashRepository | Repository::ActiveRecordRepository, ?extra_repository: Repository::YamlRepository | Repository::HashRepository | Repository::ActiveRecordRepository, ?refresh_interval_sec: Integer) -> void
+
+    def permitted?: (Symbol feature_name, ?time: nil | Time) -> bool
+
+    def current_features: -> FeatureCollection
+
+    def refresh: -> bool
+
+    def names: -> Array[Symbol]
+
+    def environments: -> Array[Symbol]
+
+    private
+
+    def to_feature: (FeatureCollection features, Symbol name, Symbol environment) -> Feature
+
+    def expired?: (?Time? time) -> bool
+
+    def load_features: -> Time
+  end
+end