railsmdb 1.0.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c5fc774da8b9ad81904fc662c1845ce3a54569183d019ac896aa67a3359a60e
+  data.tar.gz: f0e5879e0fea0e817ccc269d74050e6bbef2f60cfe75c7d58d3c6767d6af35c3
+SHA512:
+  metadata.gz: ac54e057125932ef589776d1e18f08cd221725c5660ce75207f8250c76bcf3f18f7e8b88ceec5483c60b2e7479ae4b5e069e8a01f5edbe36b5bc3af143793e3f
+  data.tar.gz: c68a7050639334ea019bd952784af540d03e57aa9600095b4b4273f2d6eff072250cb03e62fcef6d64f201739ea7eaaea6494f7fa2638fbebd88929fd9ea1dc4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2023-Present MongoDB Inc.  
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# Railsmdb for Mongoid
+
+Railsmdb is a command-line utility for creating, updating, managing,
+and maintaining Rails applications that use Mongoid and MongoDB for data storage. It is an extension of (and supports all other functionality of) the `rails` command from Ruby on Rails.
+
+
+## Installation
+
+To install Railsmdb:
+
+```
+$ gem install railsmdb
+```
+
+This will install a new command, `railsmdb`.
+
+
+## Usage
+
+The `railsmdb` command may be invoked exactly as you would invoke the `rails` command. For example, to create a new Rails app:
+
+```
+$ railsmdb new my_new_rails_app
+```
+
+This will create a new folder under the current directory called `my_new_rails_app`, and will populate it with all the scaffolding necessary to begin building your app.
+
+Unlike the `rails` command, however, it will set up the necessary gems and configuration for you to begin your Rails app using the MongoDB database, with Mongoid as the Object-Document Mapper (ODM).
+
+Also, in your new application, there will be a new script in the `bin` folder: `bin/railsmdb`. You'll see `bin/rails` in there as well, but it now links to `bin/railsmdb`.
+
+By default, `railsmdb` will not include ActiveRecord in your new application. If you wish to use both Mongoid and ActiveRecord (to connect to MongoDB and a separate, relational database in the same application), you can pass `--no-skip-active-record`:
+
+```
+$ railsmdb new my_new_rails_app --no-skip-active-record
+```
+
+This will set up your application to use both Mongoid, and sqlite3 (by default). To start with a different relational database instead, you can pass the `--database` option:
+
+```
+$ railsmdb new my_new_rails_app --no-skip-active-record --database=mysql
+```
+
+To see a list of all available commands, simply type `railsmdb` without any arguments.
+
+```
+$ railsmdb
+
+# alternatively:
+$ railsmdb -h
+```
+
+
+### Setting up railsmdb and Mongoid in an established Rails app
+
+If you want to add `railsmdb` to an existing (non-Mongoid) Rails app, and add Mongoid configuration as well, you can use `railsmdb setup`:
+
+```
+$ railsmdb setup
+```
+
+This must be run from the root directory of a Rails project. It will replace `bin/rails` with `bin/railsmdb`, add the `mongoid.yml` configuration file and the `mongoid.rb` initializer, and add the necessary gem entries to the `Gemfile`.
+
+**Note:** it is recommended to run this command in a branch, so that you can easily experiment with the changes and roll them back if necessary.
+
+
+### Generating Mongoid models
+
+You can use `railsmdb` to generate stubs for new Mongoid models. From within a project:
+
+```
+$ bin/railsmdb generate model person
+```
+
+This will create a new model at `app/models/person.rb`:
+
+```ruby
+class Person
+  include Mongoid::Document
+  include Mongoid::Timestamp
+end
+```
+
+You can specify the fields of the model as well:
+
+```ruby
+# bin/railsmdb generate model person name:string birth:date
+
+class Person
+  include Mongoid::Document
+  include Mongoid::Timestamp
+  field :name, type: String
+  field :birth, type: Date
+end
+```
+
+You can instruct the generator to make the new model a subclass of another, by passing the `--parent` option:
+
+```ruby
+# bin/railsmdb generate model student --parent=person
+
+class Student < Person
+  include Mongoid::Timestamp
+end
+```
+
+And if you need to store your models in a different collection than can be inferred from the model name, you can specify `--collection`:
+
+```ruby
+# bin/railsmdb generate model course --collection=classes
+
+class Course
+  include Mongoid::Document
+  include Mongoid::Timestamp
+  store_in collection: 'classes'
+end
+```

data/Rakefile

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rubygems/package'
+require 'rubygems/security'
+require 'rspec/core/rake_task'
+
+require_relative './lib/railsmdb/version'
+
+def signed_gem?(path_to_gem)
+  Gem::Package.new(path_to_gem, Gem::Security::HighSecurity).verify
+  true
+rescue Gem::Security::Exception
+  false
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[ -I lib -I spec/support --format documentation ]
+end
+
+task default: %i[ spec ]
+
+Rake::Task['release'].clear
+
+desc 'Release railsmdb gem'
+task release: %w[ release:require_private_key clobber build release:verify release:tag release:publish ]
+
+namespace :release do
+  desc 'Requires the private key to be present'
+  task :require_private_key do
+    raise 'No private key present, cannot release' unless File.exist?('gem-private_key.pem')
+  end
+
+  desc 'Verifies that all built gems in pkg/ are valid'
+  task :verify do
+    gems = Dir['pkg/*.gem']
+    if gems.empty?
+      puts 'There are no gems in pkg/ to verify'
+    else
+      gems.each do |gem|
+        if signed_gem?(gem)
+          puts "#{gem} is signed"
+        else
+          abort "#{gem} is not signed"
+        end
+      end
+    end
+  end
+
+  desc 'Creates a new tag for the current version'
+  task :tag do
+    system "git tag -a v#{Railsmdb::Version::STRING} -m 'Tagging release: #{Railsmdb::Version::STRING}'"
+    system "git push upstream v#{Railsmdb::Version::STRING}"
+  end
+
+  desc 'Publishes the most recently built gem'
+  task :publish do
+    system "gem push pkg/railsmdb-#{Railsmdb::Version::STRING}.gem"
+  end
+end
+
+# rubocop:enable Metrics/BlockLength

data/lib/railsmdb/cli.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails/app_loader'
+require 'railsmdb/ext/rails/command'
+require 'railsmdb/ext/rails/generators/rails/app/app_generator'
+
+# the EXECUTABLES constant might eventually be frozen, so we should do
+# this the long, difficult way...
+Rails::AppLoader.send :remove_const, :EXECUTABLES
+Rails::AppLoader::EXECUTABLES = %w[ bin/railsmdb ].freeze
+
+if ARGV.first == 'setup'
+  Rails::Command.invoke :setup, ARGV
+else
+  require 'rails/cli'
+end

data/lib/railsmdb/commands/dbconsole/dbconsole_command.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'mongoid'
+require 'rails/command/base'
+require 'rails/command/environment_argument'
+
+module Mongoid
+  module Command
+    # The implementation of the `dbconsole` command for Railsmdb.
+    class DbconsoleCommand < Rails::Command::Base
+      include Rails::Command::EnvironmentArgument
+
+      desc 'dbconsole', 'Start a console for MongoDB using the info in config/mongoid.yml'
+      def perform
+        require_application_and_environment!
+        exec_mongosh_with(Rails.env || 'default')
+      end
+
+      private
+
+      # Invokes mongosh using the config/mongoid.yml configuration for the
+      # current Rails environment. If no such configuration exists, it tries
+      # to fall back to the `default` configuration.
+      #
+      # @param [ String ] environment the named configuration to use.
+      def exec_mongosh_with(environment)
+        puts "Launching mongosh with #{environment} configuration."
+        config = find_configuration_for(environment)
+
+        command = ENV['MONGOSH_CMD'] || 'mongosh'
+
+        uri = config[:uri] || "mongodb://#{config[:hosts].first}/#{config[:database]}"
+
+        exec(command, uri)
+      rescue Errno::ENOENT
+        abort "mongosh is not installed, or is not in your PATH. Please see\n" \
+              "https://www.mongodb.com/docs/mongodb-shell for instructions on\n" \
+              'downloading and installing mongosh.'
+      end
+
+      # Looks for a Mongoid client configuration with the given name. If no
+      # such configuration exists, tries to load the `default` configuration.
+      # If that can't be found, it will abort executation.
+      #
+      # @param [ String ] environment the name of the configuration to load.
+      #
+      # @return [ Hash ] the named configuration
+      def find_configuration_for(environment)
+        config = Mongoid.clients[environment]
+        return config if config
+
+        warn "There is no #{environment} configuration defined in config/mongoid.yml."
+
+        config = Mongoid.clients[:default]
+        unless config
+          abort "There is no default configuration to fall back to.\n" \
+                'Please define a client in config/mongoid.yml.'
+        end
+
+        warn 'Using default configuration instead.'
+        config
+      end
+    end
+  end
+end

data/lib/railsmdb/commands/setup/setup_command.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails/command/base'
+require 'railsmdb/generators/setup/setup_generator'
+
+module Mongoid
+  module Command
+    # The implementation of the `setup` command for Railsmdb.
+    class SetupCommand < Rails::Command::Base
+      desc 'setup', 'Install railsmdb into an existing Rails app'
+      def perform(*args)
+        # remove the first argument, which will be `setup`, and pass
+        # the rest through to the generator
+        args.shift
+
+        Railsmdb::Generators::SetupGenerator.start(args)
+      end
+    end
+  end
+end

data/lib/railsmdb/commands.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'railsmdb/ext/rails/command'
+require 'railsmdb/ext/rails/generators'
+require 'rails/commands'

data/lib/railsmdb/crypt_shared/catalog.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'railsmdb/crypt_shared/listing'
+require 'os'
+
+module Railsmdb
+  module CryptShared
+    # A utility method for querying a catalog listing.
+    #
+    # @api private
+    class Catalog
+      class << self
+        # Return a Catalog instance representing the current listing.
+        #
+        # @return [ Catalog ] the current listing.
+        def current
+          new(Listing.fetch)
+        end
+      end
+
+      # @return [ Hash ] the current listing
+      attr_reader :listing
+
+      # Create a new Catalog instance from the giving listing.
+      #
+      # @param [ Hash ] listing the data to query
+      def initialize(listing)
+        @listing = listing
+      end
+
+      # Queries the listing data using the given criteria, yielding the
+      # corresponding download data.
+      #
+      # @example Finding all production releases for M1 macs
+      #   catalog.downloads(
+      #     production_release: true,
+      #     downloads: { arch: 'arm64', target: 'macos' }
+      #   ) do |download|
+      #     puts download['crypt_shared']['url']
+      #   end
+      #
+      # @param [ Hash ] criteria the criteria hash
+      #
+      # @yield [ Hash ] each download record matching the criteria
+      def downloads(criteria = {})
+        download_criteria = criteria.delete(:downloads) || {}
+
+        listing['versions'].each do |version|
+          next unless hash_matches?(version, criteria)
+
+          version['downloads'].each do |download|
+            next unless hash_matches?(download, download_criteria)
+
+            yield download
+          end
+        end
+
+        self
+      end
+
+      # Queries the listing for all downloads that match the platform
+      # criteria for the current host.
+      #
+      # @param [ String ] which the download entry to return
+      #
+      # @return [ Array<String, String> ] a tuple of (url, sha256) for the
+      #    requested download.
+      def optimal_download_url_for_this_host(which = 'crypt_shared')
+        downloads(production_release: true, downloads: download_criteria) do |dl|
+          return [ dl[which]['url'], dl[which]['sha256'] ]
+        end
+
+        nil
+      end
+
+      # Returns the download criteria (arch/target/edition) for the current
+      # host.
+      #
+      # @return [ Hash ] the download criteria
+      def download_criteria
+        {
+          arch: platform_arch,
+          target: platform_target,
+          edition: 'enterprise'
+        }
+      end
+
+      private
+
+      # @return [ String ] the host CPU specification.
+      def platform_arch
+        OS.host_cpu
+      end
+
+      # @return [ String ] the normalized host operating system
+      def platform_target
+        if OS.windows? || OS::Underlying.windows?
+          'windows'
+        elsif OS.mac?
+          'macos'
+        elsif OS.linux?
+          # this will almost certainly need tweaking
+          release = OS.parse_os_release
+          id = release[:ID]
+          version = release[:VERSION_ID].gsub(/[^\d]/, '')
+          "#{id}#{version}"
+        else
+          warn 'cannot install the crypt_shared library for this platform'
+        end
+      end
+
+      # Asks if the given hash satisfies all the given criteria.
+      #
+      # @param [ Hash ] hash the hash to query
+      # @param [ Hash ] criteria the criteria to use for the query
+      #
+      # @return [ true | false ] whether the hash meets the criteria or not.
+      def hash_matches?(hash, criteria)
+        criteria.all? { |key, value| hash[key.to_s] == value }
+      end
+    end
+  end
+end

data/lib/railsmdb/crypt_shared/listing.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open-uri'
+require 'tmpdir'
+
+module Railsmdb
+  module CryptShared
+    # A utility class for fetching the JSON list of current MongoDB
+    # database offerings.
+    #
+    # @api private
+    class Listing
+      # Convenience method for fetching and returning the current listing.
+      #
+      # @return [ Hash ] the parsed JSON contents of the listing
+      def self.fetch
+        new.listing
+      end
+
+      # Downloads and parses the listing, returning the result.
+      #
+      # @return [ Hash ] the parsed JSON contents of the listing
+      def listing
+        @listing ||= fetch_listing_json
+      end
+
+      private
+
+      # the URI of the current.json catalog
+      CURRENT_URI = 'https://downloads.mongodb.org/current.json'
+
+      # where the JSON file should be cached
+      CURRENT_CACHE = File.join(Dir.tmpdir, '.current.json')
+
+      # how old the cache may be before it must be fetched again
+      CACHE_CUTOFF = 24 * 60 * 60 # seconds in 24 hours
+
+      # Fetches and parses the current catalog file, first checking the
+      # cache, and then if necessary fetching from the remote server.
+      #
+      # @return [ Hash ] the parsed JSON catalog file
+      def fetch_listing_json
+        fetch_listing_json_from_cache ||
+          fetch_listing_json_from_uri
+      end
+
+      # Looks at the cache for the requested catalog file. If it doesn't
+      # exist, or if it is too old, this returns nil.
+      #
+      # @return [ Hash | nil ] the parsed JSON catalog file, or nil if
+      #    it needs to be fetched from the server
+      def fetch_listing_json_from_cache
+        return nil unless File.exist?(CURRENT_CACHE)
+        return nil unless File.mtime(CURRENT_CACHE) >= Time.now - CACHE_CUTOFF
+
+        JSON.load_file(CURRENT_CACHE)
+      end
+
+      # Fetches the requested catalog file from the server. This will
+      # save the fetched file to the cache.
+      #
+      # @return [ Hash ] the parsed JSON catalog file
+      def fetch_listing_json_from_uri
+        uri = URI.parse(CURRENT_URI)
+        File.write(CURRENT_CACHE, uri.read)
+        fetch_listing_json_from_cache
+      end
+    end
+  end
+end

data/lib/railsmdb/downloader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Railsmdb
+  # A utility class for downloading a file from a given URL.
+  class Downloader
+    # @return [ String ] the url to download from
+    attr_reader :url
+
+    # @return [ String ] where the file should be saved to.
+    attr_reader :destination
+
+    # A helper method for fetching the file in a single call.
+    #
+    # @param [ String ] url the url to fetch from
+    # @param [ String ] destination the location to write to
+    # @param [ Proc ] callback a callback block that is invoked with the
+    #   current total number of bytes read, as each chunk is read from the
+    #   stream.
+    def self.fetch(url, destination, &callback)
+      new(url, destination).fetch(&callback)
+    end
+
+    # Create a new Downloader object.
+    #
+    # @param [ String ] url the url to fetch from
+    # @param [ String ] destination the location to write to
+    def initialize(url, destination)
+      @url = url
+      @destination = destination
+    end
+
+    # Perform the fetch, pulling from the url and writing to the destination.
+    def fetch
+      File.open(destination, 'w:BINARY') do |io|
+        connection.get(url) do |req|
+          req.options.on_data = lambda do |chunk, total, _env|
+            yield total if block_given?
+            io << chunk
+          end
+        end
+      end
+
+      true
+    end
+
+    private
+
+    # The underlying HTTP connection used to query the file.
+    def connection
+      @connection ||= Faraday.new(url: url, ssl: { verify: false, verify_hostname: false })
+    end
+  end
+end

data/lib/railsmdb/ext/rails/command/behavior.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rails/command/behavior'
+
+module Railsmdb
+  # Extensions to the Rails::Command::Behavior module
+  module RailsCommandBehaviorExtension
+    module ClassMethods # :nodoc:
+      def self.included(mod)
+        mod.alias_method :rails_lookup, :lookup
+        mod.alias_method :lookup, :railsmdb_lookup
+      end
+
+      private
+
+      # Railsmdb's version of `Command#lookup`, which makes
+      # sure any `rails:` namespace is preempted by a corresponding
+      # `railsmdb:` namespace.
+      #
+      # @param [ Array<String> ] namespaces the list of namespaces
+      #   to look at
+      def railsmdb_lookup(namespaces)
+        rails_lookup(preempt_rails_namespace(namespaces))
+      end
+
+      # If a "rails:" namespace exists in the list,
+      # insert a new namespace before it with "rails:"
+      # replaced with "mongoid:"
+      #
+      # @param [ Array<String> ] namespaces the list of namespaces
+      #   to consider
+      #
+      # @return [ Array<String> ] the (possibly modified) list of
+      #   namespaces.
+      def preempt_rails_namespace(namespaces)
+        new_namespaces = []
+
+        namespaces.each do |ns|
+          if ns.match?(/\brails:/)
+            new_ns = ns.sub(/\brails:/, 'mongoid:')
+            new_namespaces.push(new_ns)
+          end
+
+          new_namespaces.push(ns)
+        end
+
+        # we need to replace the namespaces list in-place, so that the caller
+        # gets the updated namespaces.
+        namespaces.replace(new_namespaces)
+      end
+    end
+
+    ::Rails::Command::Behavior::ClassMethods.include ClassMethods
+  end
+end

data/lib/railsmdb/ext/rails/command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails/command'
+require 'railsmdb/ext/rails/command/behavior'
+
+module Rails
+  module Command # :nodoc:
+    class << self
+      private
+
+      # Prepends the railsmdb commands lookup path to the existing rails
+      # lookup paths.
+      def railsmdb_lookup_paths
+        @railsmdb_lookup_paths ||= [ 'railsmdb/commands', *rails_lookup_paths ]
+      end
+
+      alias rails_lookup_paths lookup_paths
+      alias lookup_paths railsmdb_lookup_paths
+    end
+  end
+end