mvc_one 0.1.0.pre.rc2 → 0.1.0.pre.rc4

data/lib/mvc_one/regexp_router.rb

@@ -8,120 +8,124 @@
 # get, post, delete, etc - HTTP methods
 # '/user', '/users/:id' - regexp, :id - params, available with result
 # to: 'web#users#create' - route request to Web::UsersController create method
-class MvcOne::RegexpRouter
-  HTTP_METHODS = %w[get post patch put delete options head].freeze
-
-  # concrete route
-  class Route
-    ANY_METHOD = 'any'
-    attr_reader :controller, :action, :pattern, :method
-
-    def initialize(controller:, action:, pattern:, method:)
-      @controller = controller
-      @action = action
-      @pattern = pattern
-      @method = method
-    end
+module MvcOne
+  class RegexpRouter
+    HTTP_METHODS = %w[get post patch put delete options head].freeze
+
+    # concrete route
+    class Route
+      ANY_METHOD = 'any'
+      attr_reader :controller, :action, :pattern, :method
+
+      def initialize(controller:, action:, pattern:, method:)
+        @controller = controller
+        @action = action
+        @pattern = pattern
+        @method = method
+      end
 
-    def matched?(path, http_method)
-      return true if method == ANY_METHOD
-      return false unless method.to_s == http_method.to_s
+      def matched?(path, http_method)
+        return true if method == ANY_METHOD
+        return false unless method.to_s == http_method.to_s
 
-      pattern_split = pattern.split('/')
-      path_split = path.split('/')
-      return false if pattern_split.length != path_split.length
+        pattern_split = pattern.split('/')
+        path_split = path.split('/')
+        return false if pattern_split.length != path_split.length
 
-      pattern_matched_with?(pattern_split, path_split)
-    end
+        pattern_matched_with?(pattern_split, path_split)
+      end
 
-    def params(path)
-      pattern_split = pattern.split('/')
-      path_split = path.split('/')
+      def params(path)
+        pattern_split = pattern.split('/')
+        path_split = path.split('/')
 
-      result = {}
+        result = {}
 
-      pattern_split.each_with_index do |e, index|
-        if e.start_with?(':')
-          key = e.delete(':').to_sym
-          result[key] = path_split[index]
+        pattern_split.each_with_index do |e, index|
+          if e.start_with?(':')
+            key = e.delete(':').to_sym
+            result[key] = path_split[index]
+          end
         end
-      end
 
-      result
-    end
+        result
+      end
 
-    private
+      private
 
-    def pattern_matched_with?(pattern_split, path_split)
-      matched = true
-      pattern_split.each_with_index do |e, index|
-        next if e.start_with?(':')
+      def pattern_matched_with?(pattern_split, path_split)
+        matched = true
+        pattern_split.each_with_index do |e, index|
+          next if e.start_with?(':')
 
-        if e != path_split[index]
-          matched = false
-          break
+          if e != path_split[index]
+            matched = false
+            break
+          end
         end
-      end
 
-      matched
+        matched
+      end
     end
-  end
 
-  # result of searching right route, has controller, action, params from path
-  class Result
-    attr_reader :route, :path
+    # result of searching right route, has controller, action, params from path
+    class Result
+      attr_reader :route, :path
 
-    def initialize(route, path)
-      @route = route
-      @path = path
-    end
+      def initialize(route, path)
+        @route = route
+        @path = path
+      end
 
-    def controller
-      instance_eval "#{route.controller}Controller", __FILE__, __LINE__ # Return class of matched controller
-    end
+      def controller
+        instance_eval "#{route.controller}Controller", __FILE__, __LINE__ # Return class of matched controller
+      end
 
-    def action
-      route.action
-    end
+      def action
+        route.action
+      end
 
-    def params
-      route.params(path)
+      def params
+        route.params(path)
+      end
     end
-  end
 
-  attr_reader :routes
+    attr_reader :routes
 
-  def initialize(route_path)
-    @routes = []
-    load_routes(route_path)
-  end
+    def initialize(route_path)
+      @routes = []
+      load_routes(route_path)
+    end
 
-  def resolve(path, method)
-    route = routes.find { |r| r.matched?(path, method.downcase) }
+    def resolve(path, method)
+      route = routes.find { |r| r.matched?(path, method.downcase) }
 
-    Result.new(route, path) if route
-  end
+      Result.new(route, path) if route
+    end
+
+    private
 
-  private
+    def load_routes(route_path)
+      return unless File.file?(route_path)
 
-  def load_routes(route_path)
-    instance_eval(File.read(route_path), route_path.to_s).call
-  end
+      instance_eval(File.read(route_path), route_path.to_s).call
+    end
 
-  HTTP_METHODS.each do |method|
-    define_method method do |pattern, options|
-      register_route(method, pattern, options)
+    HTTP_METHODS.each do |method|
+      define_method method do |pattern, options|
+        register_route(method, pattern, options)
+      end
     end
-  end
 
-  def any(to:)
-    register_route('any', '', to: to)
-  end
+    def any(to:)
+      register_route('any', '', to: to)
+    end
 
-  def register_route(method, pattern, options)
-    path_pieces = options[:to].split('#')
-    controller = path_pieces.slice(0..-2).map(&:capitalize).join('::')
-    action = path_pieces.last
-    @routes << Route.new(controller: controller, action: action, pattern: pattern, method: method)
+    def register_route(method, pattern, options)
+      path_pieces = options[:to].split('#')
+      controller = path_pieces.slice(0..-2).map(&:capitalize).join('::')
+      action = path_pieces.last
+      @routes << Route.new(controller: controller, action: action, pattern: pattern, method: method)
+    end
   end
 end

data/lib/mvc_one/repositories/application_relation.rb

@@ -1,35 +1,37 @@
 # frozen_string_literal: true
 
 # Base relation object
-class MvcOne::ApplicationRelation
-  def self.wrap(klass)
-    define_method :wrapped_class do
-      instance_eval klass.to_s.capitalize, __FILE__, __LINE__ # Return wrapped class
+module MvcOne
+  class ApplicationRelation
+    def self.wrap(klass)
+      define_method :wrapped_class do
+        instance_eval klass.to_s.capitalize, __FILE__, __LINE__ # Return wrapped class
+      end
     end
-  end
 
-  attr_reader :target, :attributes
+    attr_reader :target, :attributes
 
-  def initialize(attributes)
-    raise 'Please define wrapped class with wrap class method' unless respond_to?(:wrapped_class)
+    def initialize(attributes)
+      raise 'Please define wrapped class with wrap class method' unless respond_to?(:wrapped_class)
 
-    @target = wrapped_class.new(attributes)
-    @attributes = attributes
-  end
+      @target = wrapped_class.new(attributes)
+      @attributes = attributes
+    end
 
-  def method_missing(method)
-    target.send(method)
-  end
+    def method_missing(method)
+      target.send(method)
+    end
 
-  def respond_to?(method)
-    methods.include?(method) || target.respond_to?(method)
-  end
+    def respond_to?(method)
+      methods.include?(method) || target.respond_to?(method)
+    end
 
-  def respond_to_missing?(method)
-    target.respond_to_missing?(method)
-  end
+    def respond_to_missing?(method)
+      target.respond_to_missing?(method)
+    end
 
-  def class
-    target.class
+    def class
+      target.class
+    end
   end
 end

data/lib/mvc_one/repositories/application_repository.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
+require 'sequel'
+
 # Main gateway for persisted storage
-class MvcOne::ApplicationRepository
-  class NotFoundRecord < StandardError; end
+module MvcOne
+  class ApplicationRepository
+    class NotFoundRecord < StandardError; end
 
-  attr_reader :table_name
+    attr_reader :table_name
 
-  def self.db_config
-    YAML.load_file('config/database.yml')[Application::Config.env]
-  end
+    def self.db_config
+      Application::Config.db_config
+    end
 
-  DB = Sequel.connect(db_config['db']['connection_line'])
-  DB.loggers << Logger.new($stdout)
-  DB.sql_log_level = :debug
+    DB = Sequel.connect(db_config['db']['connection_line'])
+    DB.loggers << Logger.new($stdout)
+    DB.sql_log_level = :debug
+  end
 end

data/lib/mvc_one/serializers/application_serializer.rb

@@ -1,141 +1,143 @@
 # frozen_string_literal: true
 
 # All app serializers must be subclasses of ApplicationSerializer
-class MvcOne::ApplicationSerializer
-  class << self
-    def attributes(*args)
-      define_method :attributes do
-        args
+module MvcOne
+  class ApplicationSerializer
+    class << self
+      def attributes(*args)
+        define_method :attributes do
+          args
+        end
       end
-    end
 
-    def type(type)
-      define_method :type do
-        type.to_s
+      def type(type)
+        define_method :type do
+          type.to_s
+        end
       end
-    end
 
-    def id
-      raise ArgumentError, 'No block given' unless block_given?
+      def id
+        raise ArgumentError, 'No block given' unless block_given?
 
-      define_method :id do
-        yield data
+        define_method :id do
+          yield data
+        end
       end
-    end
 
-    def links
-      raise ArgumentError, 'No block given' unless block_given?
+      def links
+        raise ArgumentError, 'No block given' unless block_given?
 
-      define_method :links do
-        yield data
+        define_method :links do
+          yield data
+        end
       end
-    end
 
-    def has_one(relation)
-      raise ArgumentError, 'No block given' unless block_given?
+      def has_one(relation)
+        raise ArgumentError, 'No block given' unless block_given?
 
-      define_method relation do
-        yield data
+        define_method relation do
+          yield data
+        end
       end
     end
-  end
 
-  attr_reader :data
+    attr_reader :data
 
-  def initialize(data, include: [])
-    @data = data
-    @include = include
-  end
+    def initialize(data, include: [])
+      @data = data
+      @include = include
+    end
 
-  def serialize
-    result = {}
-    if data.is_a?(Enumerable)
-      result[:data] = data.map { |e| self.class.new(e, include: @include).serialize_data }
-      included = data.flat_map { |e| self.class.new(e, include: @include).included_serialization }.compact
-      result[:included] = included if included.any?
-    else
-      result[:data] = data_serialization
-      result[:included] = included_serialization if included_serialization
+    def serialize
+      result = {}
+      if data.is_a?(Enumerable)
+        result[:data] = data.map { |e| self.class.new(e, include: @include).serialize_data }
+        included = data.flat_map { |e| self.class.new(e, include: @include).included_serialization }.compact
+        result[:included] = included if included.any?
+      else
+        result[:data] = data_serialization
+        result[:included] = included_serialization if included_serialization
+      end
+      result
     end
-    result
-  end
 
-  def serialize_data
-    data_serialization
-  end
+    def serialize_data
+      data_serialization
+    end
 
-  def data_serialization
-    raise NoMethodError if data.is_a?(Enumerable)
+    def data_serialization
+      raise NoMethodError if data.is_a?(Enumerable)
 
-    result = {}
-    add_type(result)
-    add_id(result)
-    add_attributes(result)
-    add_links(result)
-    add_relatioship(result)
-    result
-  end
+      result = {}
+      add_type(result)
+      add_id(result)
+      add_attributes(result)
+      add_links(result)
+      add_relatioship(result)
+      result
+    end
 
-  def included_serialization
-    return nil if @include.empty?
+    def included_serialization
+      return nil if @include.empty?
 
-    @include.map do |include|
-      raise(NoMethodError, "Undefined #{include} include") unless respond_to?(include)
+      @include.map do |include|
+        raise(NoMethodError, "Undefined #{include} include") unless respond_to?(include)
 
-      send(include)
+        send(include)
+      end
     end
-  end
 
-  private
+    private
 
-  def add_relatioship(result)
-    result[:relationships] = {} unless @include.empty?
-    @include.each do |include|
-      raise(NoMethodError, "Undefined #{include} include") unless respond_to?(include)
+    def add_relatioship(result)
+      result[:relationships] = {} unless @include.empty?
+      @include.each do |include|
+        raise(NoMethodError, "Undefined #{include} include") unless respond_to?(include)
 
-      included_entity = send(include)
-      included_relationship = {}
-      included_relationship[:data] = included_entity.slice(:id, :type)
-      result[:relationships][include] = included_relationship
+        included_entity = send(include)
+        included_relationship = {}
+        included_relationship[:data] = included_entity.slice(:id, :type)
+        result[:relationships][include] = included_relationship
+      end
     end
-  end
 
-  def add_links(result)
-    result[:links] = links if respond_to?(:links)
-  end
+    def add_links(result)
+      result[:links] = links if respond_to?(:links)
+    end
 
-  def add_type(result)
-    result[:type] = respond_to?(:type) ? type : default_type
-  end
+    def add_type(result)
+      result[:type] = respond_to?(:type) ? type : default_type
+    end
 
-  def add_id(result)
-    result[:id] = respond_to?(:id) ? id : default_id
-  end
+    def add_id(result)
+      result[:id] = respond_to?(:id) ? id : default_id
+    end
 
-  def add_attributes(result)
-    return unless respond_to?(:attributes)
+    def add_attributes(result)
+      return unless respond_to?(:attributes)
 
-    result_attributes = attributes.each_with_object({}) do |attr, acc|
-      acc[attr] = get_attribute(attr)
+      result_attributes = attributes.each_with_object({}) do |attr, acc|
+        acc[attr] = get_attribute(attr)
+      end
+      result[:attributes] = result_attributes
     end
-    result[:attributes] = result_attributes
-  end
 
-  def default_type
-    data.class.to_s.downcase
-  end
+    def default_type
+      data.class.to_s.downcase
+    end
 
-  def default_id
-    data.id.to_s
-  end
+    def default_id
+      data.id.to_s
+    end
 
-  def get_attribute(attr)
-    if respond_to?(attr)
-      send(attr)
-    elsif data.respond_to?(attr)
-      data.send(attr)
-    else
-      raise NoMethodError, "Undefined serialize key #{attr}"
+    def get_attribute(attr)
+      if respond_to?(attr)
+        send(attr)
+      elsif data.respond_to?(attr)
+        data.send(attr)
+      else
+        raise NoMethodError, "Undefined serialize key #{attr}"
+      end
     end
   end
 end

data/lib/mvc_one/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MvcOne
-  VERSION = "0.1.0-rc2"
+  VERSION = '0.1.0-rc4'
 end

data/lib/mvc_one.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "mvc_one/version"
+require_relative 'mvc_one/version'
+require_relative 'mvc_one/application'
 
+# Global namespace
 module MvcOne
-  class Error < StandardError; end
-  # Your code goes here...
 end

data/mvc_one.gemspec

@@ -1,45 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "lib/mvc_one/version"
+require_relative 'lib/mvc_one/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "mvc_one"
+  spec.name = 'mvc_one'
   spec.version = MvcOne::VERSION
-  spec.authors = ["Evgenii Sendziuk"]
-  spec.email = ["evgeniisendziuk@taxdome.com"]
+  spec.authors = ['Evgenii Sendziuk']
+  spec.email = ['evgeniisendziuk@taxdome.com']
 
-  spec.summary = "Simple mvc framework, not for production purposes"
-  spec.description = "Simple mvc framework, not for production purposes"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.summary = 'Simple mvc framework, not for production purposes'
+  spec.description = 'Simple mvc framework, not for production purposes'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
 
-
-  spec.metadata["source_code_uri"] = "https://github.com/senzpo/mvc_one.git"
-  spec.metadata["changelog_uri"] = "https://github.com/senzpo/mvc_one.git"
+  spec.metadata['source_code_uri'] = 'https://github.com/senzpo/mvc_one.git'
+  spec.metadata['changelog_uri'] = 'https://github.com/senzpo/mvc_one.git'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+      (File.expand_path(f) == __FILE__) ||
+        f.match(%r{\A(?:(?:bin|test|spec|features|config)/|\.(?:git|circleci)|appveyor)})
     end
   end
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   # Uncomment to register a new dependency of your gem
-  spec.add_dependency "thor"
-  spec.add_dependency "slim"
-  spec.add_dependency "bcrypt"
-  spec.add_dependency "rack"
-  spec.add_dependency "rack-session"
-  spec.add_dependency "sequel"
-  spec.add_dependency "sqlite3"
-  spec.add_dependency "dry-struct"
-  spec.add_dependency "dry-transaction"
-  spec.add_dependency "dry-validation"
+  spec.add_dependency 'bcrypt', '~> 3.1'
+  spec.add_dependency 'dry-struct', '~> 1.5'
+  spec.add_dependency 'dry-transaction', '~> 0.14'
+  spec.add_dependency 'dry-validation', '~> 1.9'
+  spec.add_dependency 'rack', '~> 3'
+  spec.add_dependency 'rack-session', '~> 2'
+  spec.add_dependency 'sequel', '~> 5.60'
+  spec.add_dependency 'slim', '~> 5'
+  spec.add_dependency 'sqlite3', '~> 1.5'
+  spec.add_dependency 'thor', '~> 1.2'
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end