jun 0.0.1 → 0.3.0

data/lib/jun/active_record/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../connection_adapters/sqlite_adapter"
+require_relative "./persistence"
+
+module ActiveRecord
+  class Base
+    include ActiveRecord::Persistence
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      @new_record = true
+    end
+
+    def method_missing(name, *args)
+      if self.class.connection.columns(self.class.table_name).include?(name)
+        @attributes[name]
+      else
+        super
+      end
+    end
+
+    def self.find(id)
+      find_by_sql("SELECT * FROM #{table_name} WHERE id = #{id.to_i} LIMIT 1").first
+    end
+
+    def self.all
+      ActiveRecord::Relation.new(self)
+    end
+
+    def self.where(*args)
+      all.where(*args)
+    end
+
+    def self.find_by_sql(sql)
+      connection.execute(sql).map do |attributes|
+        object = new(attributes)
+        object.instance_variable_set("@new_record", false)
+
+        object
+      end
+    end
+
+    def self.table_name
+      name.downcase.pluralize
+    end
+
+    def self.connection
+      @@connection ||= SqliteAdapter.new
+    end
+  end
+end

data/lib/jun/active_record/migration.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    def up
+      raise NoMethodError, "Subclass must implement method."
+    end
+
+    def down
+      raise NoMethodError, "Subclass must implement method."
+    end
+
+    def add_column(table_name, column_name, column_type, options = {})
+      sql = ["ALTER TABLE #{table_name} ADD COLUMN #{column_name}"]
+
+      sql << column_type.to_s.upcase
+      sql << "NOT NULL" if options[:null] == false
+      sql << "DEFAULT #{options[:default]}" if options[:default]
+      sql << "UNIQUE" if options[:unique] == true
+
+      execute(sql.join(" "))
+    end
+
+    def remove_column(table_name, column_name)
+      execute("ALTER TABLE #{table_name} DROP COLUMN #{column_name};")
+    end
+
+    def create_table(table_name, options = {})
+      sql = "CREATE TABLE IF NOT EXISTS #{table_name}"
+      column_options = []
+
+      if options[:id] || !options.key?(:id)
+        column_options << {
+          name: :id,
+          type: :integer,
+          primary_key: true,
+          null: false
+        }
+      end
+
+      column_options += options.fetch(:columns, [])
+
+      columns_sql = column_options.map do |column|
+        next(column) if column.is_a?(String)
+
+        column_sql = []
+
+        column_sql << column[:name]
+        column_sql << column[:type]&.to_s&.upcase
+        column_sql << "PRIMARY KEY" if column[:primary_key] == true
+        column_sql << "NOT NULL" if column[:null] == false
+        column_sql << "DEFAULT #{column[:default]}" if column[:default]
+        column_sql << "UNIQUE" if column[:unique] == true
+
+        column_sql.compact.join(" ")
+      end
+
+      sql += " (#{columns_sql.join(", ")})"
+      sql += ";"
+
+      execute(sql)
+    end
+
+    def drop_table(table_name)
+      execute("DROP TABLE IF EXISTS #{table_name};")
+    end
+
+    def rename_table(old_table_name, new_table_name)
+      execute("ALTER TABLE #{old_table_name} RENAME TO #{new_table_name};")
+    end
+
+    def execute(*args)
+      ActiveRecord::Base.connection.execute(*args)
+    end
+  end
+end

data/lib/jun/active_record/migrator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migrator
+    ALLOWED_DIRECTIONS = %w[up down].freeze
+
+    def initialize(direction:)
+      unless ALLOWED_DIRECTIONS.include?(direction.to_s)
+        raise ArgumentError, "direction must be one of: #{ALLOWED_DIRECTIONS.inspect}"
+      end
+
+      @direction = direction.to_s
+    end
+
+    def call
+      process_migrations!
+    end
+
+    private
+
+    def process_migrations!
+      files_to_process = up_migration? ? pending_migration_files : processed_migration_files.last(1)
+
+      files_to_process.each do |filepath|
+        require filepath
+
+        filename = filepath.split("/").last.sub(".rb", "")
+        migration_version = filename.split("_").first
+        migration_class_name = filename.split("_", 2).last.camelize
+        migration_class = Object.const_get(migration_class_name)
+
+        migration_class.new.public_send(@direction)
+        up_migration? ? add_to_schema_migrations(migration_version) :
+                        remove_from_schema_migrations(migration_version)
+
+        migration_verb = up_migration? ? "processed" : "rolled back"
+        puts "Migration #{migration_verb} (#{filename})."
+      end
+
+      dump_schema! if files_to_process.any?
+    end
+
+    def up_migration?
+      @direction == "up"
+    end
+
+    def pending_migration_files
+      @pending_migration_files ||= migration_files - processed_migration_files
+    end
+
+    def processed_migration_files
+      @processed_migration_files ||= migration_files.select do |filepath|
+        file_version = filepath.split("/").last.split("_").first
+        processed_versions.include?(file_version)
+      end
+    end
+
+    def migration_files
+      @migration_files ||= Dir.glob(Jun.root.join("db/migrate/*.rb")).sort
+    end
+
+    def processed_versions
+      ActiveRecord::Base.connection.execute("SELECT * FROM schema_migrations;").map do |attributes|
+        attributes[:version]
+      end
+    end
+
+    def add_to_schema_migrations(version)
+      ActiveRecord::Base.connection.execute("INSERT INTO schema_migrations (version) VALUES (#{version});")
+    end
+
+    def remove_from_schema_migrations(version)
+      ActiveRecord::Base.connection.execute("DELETE FROM schema_migrations WHERE version = #{version};")
+    end
+
+    def dump_schema!
+      Jun::CLI.process_command(["db:schema:dump"])
+    end
+  end
+end

data/lib/jun/active_record/persistence.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Persistence
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def create(attributes = {})
+        object = new(attributes)
+        object.save
+
+        object
+      end
+
+      def primary_key=(value)
+        @primary_key = value.to_sym
+      end
+
+      def primary_key
+        defined?(@primary_key) ? @primary_key : :id
+      end
+    end
+
+    def save
+      if new_record?
+        result = self.class.connection.execute(
+          <<~SQL
+            INSERT INTO #{self.class.table_name}
+            (#{@attributes.keys.join(",")})
+            VALUES (#{@attributes.values.map { |v| "'#{v}'" }.join(",")})
+            RETURNING *;
+          SQL
+        )
+
+        @attributes[self.class.primary_key] = result.first[self.class.primary_key]
+        @new_record = false
+      else
+        self.class.connection.execute(
+          <<~SQL
+            UPDATE #{self.class.table_name}
+            SET #{@attributes.map { |k, v| "#{k} = #{v.nil? ? 'NULL' : "'#{v}'"}" }.join(",")}
+            WHERE id = #{id};
+          SQL
+        )
+      end
+
+      true
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def persisted?
+      !new_record?
+    end
+  end
+end

data/lib/jun/active_record/relation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    def initialize(klass)
+      @klass = klass
+      @where_clauses = []
+    end
+
+    def where!(condition)
+      clause = condition.is_a?(String) ? condition : condition.map { |k, v| "#{k} = #{v}" }.join(" AND ")
+      @where_clauses << clause
+
+      self
+    end
+
+    def where(condition)
+      clone.where!(condition)
+    end
+
+    def to_sql
+      sql = "SELECT * FROM #{@klass.table_name}"
+      sql += " WHERE #{@where_clauses.join(" AND ")}" if @where_clauses.any?
+
+      sql
+    end
+
+    def records
+      @records ||= @klass.find_by_sql(to_sql)
+    end
+
+    alias to_a records
+
+    def first
+      records.first
+    end
+
+    def each(&block)
+      records.each(&block)
+    end
+  end
+end

data/lib/jun/active_support/core_ext/array/access.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Array
+  def second
+    self[1]
+  end
+
+  def third
+    self[2]
+  end
+
+  def fourth
+    self[3]
+  end
+
+  def fifth
+    self[4]
+  end
+
+  def third_to_last
+    self[-3]
+  end
+
+  def second_to_last
+    self[-2]
+  end
+end

data/lib/jun/active_support/core_ext/array/conversion.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Array
+  def to_sentence(delimiter: ", ", last_delimiter: "and")
+    return "" if none?
+    return self.first if one?
+
+    "#{self[0...-1].join(delimiter)} #{last_delimiter} #{self[-1]}"
+  end
+end

data/lib/jun/active_support/core_ext/hash/transformation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Hash
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+
+  def stringify_keys!
+    transform_keys!(&:to_s)
+  end
+
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+
+  def symbolize_keys!
+    transform_keys! { |key| key.to_sym rescue key }
+  end
+end

data/lib/jun/active_support/core_ext/string/access.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class String
+  def at(position)
+    self[position]
+  end
+
+  def from(position)
+    self[position, length]
+  end
+
+  def to(position)
+    position += size if position.negative?
+    position = -1 if position.negative?
+
+    self[0, position + 1]
+  end
+end

data/lib/jun/active_support/core_ext/string/inflector.rb

@@ -0,0 +1,119 @@
+module Inflector
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  PLURAL = {
+            '(quiz)$'                     => '\1zes',
+            '^(ox)$'                      => '\1en',
+            '([m|l])ouse$'                => '\1ice',
+            '(matr|vert|ind)ix|ex$'       => '\1ices',
+            '(x|ch|ss|sh)$'               => '\1es',
+            '([^aeiouy]|qu)y$'            => '\1ies',
+            '(hive)$'                     => '\1s',
+            '(?:([^f])fe|([lr])f)$'       => '\1\2ves',
+            '(shea|lea|loa|thie)f$'       => '\1ves',
+            'sis$'                        => 'ses',
+            '([ti])um$'                   => '\1a',
+            '(tomat|potat|ech|her|vet)o$' => '\1oes',
+            '(bu)s$'                      => '\1ses',
+            '(alias)$'                    => '\1es',
+            '(octop)us$'                  => '\1i',
+            '(ax|test)is$'                => '\1es',
+            '(us)$'                       => '\1es',
+            '([^s]+)$'                    => '\1s'
+           }
+
+  SINGULAR = {
+              '(quiz)zes$'             => '\1',
+              '(matr)ices$'            => '\1ix',
+              '(vert|ind)ices$'        => '\1ex',
+              '^(ox)en$'               => '\1',
+              '(alias)es$'             => '\1',
+              '(octop|vir)i$'          => '\1us',
+              '(cris|ax|test)es$'      => '\1is',
+              '(shoe)s$'               => '\1',
+              '(o)es$'                 => '\1',
+              '(bus)es$'               => '\1',
+              '([m|l])ice$'            => '\1ouse',
+              '(x|ch|ss|sh)es$'        => '\1',
+              '(m)ovies$'              => '\1ovie',
+              '(s)eries$'              => '\1eries',
+              '([^aeiouy]|qu)ies$'     => '\1y',
+              '([lr])ves$'             => '\1f',
+              '(tive)s$'               => '\1',
+              '(hive)s$'               => '\1',
+              '(li|wi|kni)ves$'        => '\1fe',
+              '(shea|loa|lea|thie)ves$'=> '\1f',
+              '(^analy)ses$'           => '\1sis',
+              '((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$' => '\1\2sis',
+              '([ti])a$'               => '\1um',
+              '(n)ews$'                => '\1ews',
+              '(h|bl)ouses$'           => '\1ouse',
+              '(corpse)s$'             => '\1',
+              '(us)es$'                => '\1',
+              's$'                     => ''
+             }
+
+  UNCHANGEABLE = [
+                  'sheep',
+                  'fish',
+                  'deer',
+                  'moose',
+                  'series',
+                  'species',
+                  'money',
+                  'rice',
+                  'information',
+                  'equipment'
+                 ]
+
+  def pluralize
+    return self if UNCHANGEABLE.include? self
+
+    pattern, replacement = ""
+    PLURAL.each do |k, v|
+      if self.match(k)
+        pattern = Regexp.new(k)
+        replacement = v
+        break
+      end
+    end
+    self.sub(pattern, replacement)
+  end
+
+  def singularize
+    return self if UNCHANGEABLE.include? self
+
+    pattern, replacement = ""
+    SINGULAR.each do |k, v|
+      if self.match(k)
+        pattern = Regexp.new(k)
+        replacement = v
+        break
+      end
+    end
+    self.sub(pattern, replacement)
+  end
+
+  def underscore
+    gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+  def camelize
+    sub(/^[a-z\d]*/) { |match| match.capitalize }.
+    gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.
+    gsub("/", "::")
+  end
+
+  module ClassMethods
+  end
+end
+
+class String
+  include Inflector
+end

data/lib/jun/active_support/core_ext.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.expand_path("core_ext/**/*.rb", __dir__)].sort.each do |filepath|
+  require_relative filepath
+end

data/lib/jun/active_support/dependencies.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jun
+  module ActiveSupport
+    module Dependencies
+      extend self
+
+      attr_accessor :autoload_paths
+      self.autoload_paths = []
+
+      def find_file(filename)
+        autoload_paths.each do |path|
+          filepath = File.join(path, "#{filename}.rb")
+          return filepath if File.file?(filepath)
+        end
+
+        nil
+      end
+    end
+  end
+end
+
+class Object
+  def self.const_missing(constant_name)
+    file = Jun::ActiveSupport::Dependencies.find_file(constant_name.to_s.underscore)
+    super if file.nil?
+
+    require file.sub(/\.rb\z/, "")
+    Object.const_get(constant_name)
+  end
+end

data/lib/jun/application.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Jun
+  class Application
+    def self.inherited(subclass)
+      super
+      Jun.app_class = subclass
+    end
+
+    def call(env)
+      routes.call(env)
+    end
+
+    def routes
+      @routes ||= Jun::ActionDispatch::Routing::RouteSet.new
+    end
+
+    def initialize!
+      return false if initialized? || Jun.application.nil?
+
+      # Add app/* directories to autoload paths.
+      Jun::ActiveSupport::Dependencies.autoload_paths += Jun.root.join("app").children
+
+      # Set up routes and make its helpers available to controllers & views.
+      require Jun.root.join("config/routes.rb")
+      url_helpers = Jun.application.routes.url_helpers
+      Jun::ActionController::Base.include(url_helpers)
+      Jun::ActionView::Base.include(url_helpers)
+
+      # Include all helpers in app/helpers directory.
+      Dir.glob(Jun.root.join("app/helpers/**/*.rb")).each do |filepath|
+        helper_class_name = File.basename(filepath, ".rb").camelize
+        helper_class = Object.const_get(helper_class_name)
+
+        Jun::ActionView::Base.include(helper_class)
+      end
+
+      @initialized = true
+    end
+
+    def initialized?
+      !!@initialized
+    end
+  end
+end

data/lib/jun/cli/commands/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jun
+  module CLI
+    module Commands
+      class Base
+        def self.command_name
+          name.sub("Jun::CLI::Commands::", "").underscore.gsub("/", ":")
+        end
+
+        def process(*args)
+          raise NoMethodError, "Subclass must implement method."
+        end
+      end
+    end
+  end
+end

data/lib/jun/cli/commands/db/create.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jun
+  module CLI
+    module Commands
+      module DB
+        class Create < Base
+          def process(*args)
+            db_filepath = Jun.root.join("db/app.db")
+
+            if File.exist?(db_filepath)
+              puts "Database already exists."
+            else
+              File.open(db_filepath, "w") {}
+              create_schema_migrations_table
+              puts "Created database in #{db_filepath}."
+            end
+          end
+
+          private
+
+          def create_schema_migrations_table
+            ActiveRecord::Base.connection.execute(
+              <<~SQL
+                CREATE TABLE IF NOT EXISTS schema_migrations (
+                  version text NOT NULL PRIMARY KEY
+                );"
+              SQL
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jun/cli/commands/db/drop.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jun
+  module CLI
+    module Commands
+      module DB
+        class Drop < Base
+          def process(*args)
+            db_filepath = Jun.root.join("db/app.db")
+
+            File.delete(db_filepath) if File.exist?(db_filepath)
+            puts "Dropped database."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jun/cli/commands/db/migrate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jun
+  module CLI
+    module Commands
+      module DB
+        class Migrate < Base
+          def process(*args)
+            ActiveRecord::Migrator.new(direction: :up).call
+          end
+        end
+      end
+    end
+  end
+end