laforge 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b541939a70c5422d9a39a36cb396eb371a4d9aa9068117e3ce8d0a23293d3bf
+  data.tar.gz: 4c2158ddb780dce754fb05b4776f409f30140f07b4b9ec4880068a1dd079f82d
+SHA512:
+  metadata.gz: ccfb3d1db0a662a1f7c2092f46f67bad2b9726661fbe240be0a0f24b9a1a50f56d7e1d9ac4287099bf4d1bc47fff6d17534b15e7c0364db8dcfaf1fa5041bedd
+  data.tar.gz: 29773c22f931db03b2359b044acd8d31e705fe14d2eec77388527e07f690e0ed815e10d057a4a40c12ec4383f7795596261d8e30f7d74e7a14503f45079aa893

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Nicholas Jakobsen
+
+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/Rakefile

@@ -0,0 +1,20 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/internal/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks
+
+
+# Add Rspec tasks
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/Readme.md

@@ -0,0 +1,75 @@
+# LaForge [![Gem Version](https://badge.fury.io/rb/laforge.svg)](https://badge.fury.io/rb/laforge)
+
+By [Combinaut](http://www.combinaut.com).
+
+**LaForge** is a gem that makes it easy to build records using data from several data sources. It aims to facilitate
+management of which data sources a record is assembled from, and to perform the actual data assembly in order to output
+a record.
+
+Key features:
+
+- Allows published content to be edited without those changes immediately being seen by visitors
+- Can selectively update content without needing to sync the entire database with production
+
+## Setup
+1. Add **Laforge** to your Gemfile:
+
+  ```ruby
+  gem 'laforge', github: 'combinaut/laforge'
+  ```
+
+2. Add laforge to your model.
+
+  ```ruby
+    # In your model
+    class MyModel < ApplicationModel
+      laforged
+    end
+  ```
+
+## Usage
+
+1. Create some sources and prioritize them, giving higher priority to sources whose attributes should override those
+   same attributes from lower priority sources.
+
+  ```ruby
+    source1 = LaForge::DataSource.create(name: 'Encyclopedia Britannica', priority: 2)
+    source2 = LaForge::DataSource.create(name: 'Wikipedia', priority: 1)
+  ```
+
+2. Build a new model, or update an existing one with data from any of your sources.
+
+  ```ruby
+    foo = MyModel.new
+    foo.record_data_entries({ height: 20, width: 5 }, source1)
+    foo.record_data_entries({ height: 19, name: 'El Capitan' }, source2)
+    foo.forge! # => Saves the model with the attributes { height: 20, width: 5, name: 'El Capitan' }
+  ```
+
+### Overriding Priority
+
+The priority of a data entry can be customized to override the priority inherited from the data source.
+
+  ```ruby
+    foo = MyModel.new
+    foo.record_data_entries({ height: 20, width: 5 }, source1)
+    foo.record_data_entries({ height: 19 }, source2, priority: 3) # Override the priority inherited from the data source
+    foo.forge! # => Saves the model with the attributes { height: 19, width: 5 }
+  ```
+
+### Querying
+  ```ruby
+    MyModel.from_data_source(source1) # => All records from source1
+    MyModel.without_data_source # => All records without any data source
+    MyModel.without_data_source(source1) # => All records not from source1
+
+    MyModel.with_attribute_from_data_source(:height, source1) # => All records with a recorded height attribute from source1
+    MyModel.with_attribute_from_data_source([:height, :width], source1) # => All records with a recorded height or width attribute from source1
+    MyModel.with_attribute_from_data_source(:height, source1).with_attribute_from_data_source(:width, source1) # => All records with a recorded height and width attribute from source1
+
+    MyModel.without_attribute_from_data_source(:height) # => All records without a recorded height attribute from any source
+    MyModel.without_attribute_from_data_source(:height, source1) # => All records without a recorded height attribute from source1
+    MyModel.without_attribute_from_data_source([:height, :width], source1) # => All records missing a recorded height or missing a recorded width from source1
+    MyModel.without_attribute_from_data_source(:height, source1).without_attribute_from_data_source(:width, source1) # => All records without both a recorded height and width attribute from source1
+
+  ```

data/app/models/laforge/data_entry.rb

@@ -0,0 +1,31 @@
+# create_table :laforge_data_entries do |t|
+#   t.belongs_to :record, polymorphic: true, null: false, index: false
+#   t.string :attribute, null: false
+#   t.belongs_to :source, null: false, index: false
+#   t.text :value
+#   t.integer :priority
+#   t.timestamps null: false
+# end
+# add_index :laforge_data_entries, [:record_id, :record_type, :attribute, :source_id]
+
+
+module LaForge
+  class DataEntry < ActiveRecord::Base
+    belongs_to :record, polymorphic: true
+    belongs_to :source, class_name: 'LaForge::DataSource'
+
+    delegate :priority, to: :source, prefix: true, allow_nil: true
+
+    before_save :normalize_value
+
+    def priority_with_fallback
+      priority || source_priority
+    end
+
+    private
+
+    def normalize_value
+      self.value = nil unless value.present?
+    end
+  end
+end

data/app/models/laforge/data_source.rb

@@ -0,0 +1,7 @@
+module LaForge
+  class DataSource < ActiveRecord::Base
+    has_many :data_entries, class_name: 'LaForge::DataEntry'
+
+    validates_presence_of :priority
+  end
+end

data/lib/laforge.rb

@@ -0,0 +1,5 @@
+require 'rails/all'
+require 'laforge/activerecord'
+
+module LaForge
+end

data/lib/laforge/activerecord.rb

@@ -0,0 +1,104 @@
+# TODO: create generator to generate tables
+module LaForge
+  module ActiveRecord
+    def self.laforged
+      has_many :data_entries, dependent: :delete_all, class_name: 'LaForge::DataEntry'
+      has_many :data_sources, through: :source_data_entries, class_name: 'LaForge::DataSource'
+
+      scope :from_data_source, ->(source) { joins(:data_entries).merge(DataEntry.from_source(source)) }
+      scope :with_attribute_from_data_source, ->(attribute, source) { joins(:data_entries).merge(DataEntry.for_attribute(attribute).from_source(source)) }
+      scope :without_data_source, ->(source = nil) { source.nil? ? left_outer_joins(:data_entries).where(data_entries: { source_id: nil }) : left_outer_joins(:data_entries).where.not(data_entries: { source_id: source }) }
+      scope :without_attribute_from_data_source, ->(attribute, source = nil) { source.nil? ? left_outer_joins(:data_entries).merge(DataEntry.for_attribute(attribute)).where(data_entries: { source_id: nil }) : left_outer_joins(:data_entries).merge(DataEntry.for_attribute(attribute)).where.not(data_entries: { source_id: source }) }
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+
+  module ClassMethods
+    # Create a record from the given data entries
+    def forge!(data_entries)
+
+    end
+  end
+
+  module InstanceMethods
+    # Assign attributes and save the record based on the data entries
+    def forge!(**forge_options)
+      forge(**forge_options)
+      save!
+    end
+
+    # Assign attributes based on the data entries
+    def forge(**forge_options)
+      self.attributes = forge_attributes(**forge_options)
+    end
+
+    # Returns a hash of the attribute changes between the saved record and the data entries
+    def forge_diff(**forge_options)
+      diff = {}
+      forge_attrs = forge_attributes(**forge_options)
+      record_attrs = slice(*forge_attrs.keys)
+
+      record_attrs.each do |key, value|
+        diff[key] = [value, forge_attrs[key]] if forge_attrs[key] != value
+      end
+
+      return diff
+    end
+
+    # Returns a hash of the attributes generated from the record's the data entries
+    # Optionally pass `attributes` to limit data entries used in the calculation to only those for the given attributes
+    # Optionally pass `sources` to limit data entries used in the calculation to only those from the given sources
+    def forge_attributes(attributes: nil, sources: nil)
+      forged_attrs = {}
+      filter_loaded_data_entries(attributes: attributes, sources: sources, present: true).sort_by(&:priority_with_fallback).reverse.uniq_by(&:attribute).each do |data_entry|
+        forged_attrs[data_entry.attribute] = data_entry.value
+      end
+
+      return forged_attrs
+    end
+
+    # Record several pieces of information from the same source.
+    def record_data_entries(attributes_hash, source, **data_entry_options)
+      attributes_hash.each do |attribute, value|
+        record_data_entry(attribute, value, source, **data_entry_options)
+      end
+    end
+
+    # Record a single piece of information from a source.
+    # Optionally pass a custom priority for that attribute and source at the same time.
+    # Optionally pass `replace: false` to leave the existing entry for the attribute and source instead of deleting it
+    def record_data_entry(attribute, value, source, priority: nil, replace: true)
+      data_entries.destroy(*filter_loaded_data_entries(attributes: attribute, sources: source)) if replace
+      data_entries << DataEntry.new(attribute: attribute, value: value, source: source, priority: priority)
+    end
+
+    # Set and save the priority of a source for the source of a single attribute
+    def update_attribute_source_priority(attribute, source, priority)
+      filter_loaded_data_entries(attributes: attribute, sources: source).each {|data_entry| data_entry.update(priority: priority) }
+    end
+
+    private
+
+    # Returns a list of the entries matching the filters
+    def filter_loaded_data_entries(attributes: nil, sources: nil, present: nil)
+      list = data_entries.to_a
+
+      unless attribute.nil?
+        attributes = Array.wrap(attributes).map(&:to_s)
+        list.select! {|data_entry| attributes.include?(data_entry.attribute) }
+      end
+
+      unless sources.nil?
+        sources = Array.wrap(sources).map {|source| source.id if source.is_a?(ActiveRecord::Base) }
+        list.select! {|data_entry| sources.include?(data_entry.source_id) }
+      end
+
+      list.select!(&:present?) if present == true
+      list.reject!(&:present?) if present == false
+
+      return list
+    end
+  end
+end

data/lib/laforge/version.rb

@@ -0,0 +1,3 @@
+module LaForge
+  VERSION = "0.0.1.alpha"
+end

data/lib/tasks/laforge_tasks.rake

@@ -0,0 +1,39 @@
+namespace :laforge do
+  desc "Polls the commit entries table for changes to sync to production"
+  task :auto_sync, [:delay] => :environment do |t, args|
+    delay = args[:delay].present? ? args[:delay].to_i : 5.seconds
+    LaForge::Staging::Synchronizer.auto_sync(delay)
+  end
+
+  desc "Syncs records that don't need confirmation to production"
+  task :sync, [:limit] => :environment do |t, args|
+    limit = args[:limit].present? ? args[:limit].to_i : nil
+    LaForge::Staging::Synchronizer.sync(limit)
+  end
+
+  desc "Syncs all records to production, including those that require confirmation"
+  task :sync_all => :environment do
+    LaForge::Staging::Synchronizer.sync_all
+  end
+
+  # Enhance the regular tasks to run on both staging and production databases
+  def rake_both_databases(task, laforge_task = task.gsub(':','_'))
+    task(laforge_task => :environment) do
+      LaForge::Database.each do |connection_name|
+        LaForge::Connection.with_production_writes do
+          puts "#{connection_name}"
+          Rake::Task[task].reenable
+          Rake::Task[task].invoke
+        end
+      end
+      Rake::Task[task].clear
+    end
+
+    # Enhance the original task to run the laforge_task as a prerequisite
+    Rake::Task[task].enhance(["laforge:#{laforge_task}"])
+  end
+
+  rake_both_databases('db:migrate')
+  rake_both_databases('db:rollback')
+  rake_both_databases('db:test:load_structure')
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: laforge
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha
+platform: ruby
+authors:
+- Nicholas Jakobsen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.10
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: LaForge is a gem that makes it easy to build records using data from
+  several data sources. It aims to facilitate management of which data sources a record
+  is assembled from, and to perform the actual data assembly in order to output a
+  record.
+email:
+- nicholas@combinaut.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- Readme.md
+- app/models/laforge/data_entry.rb
+- app/models/laforge/data_source.rb
+- lib/laforge.rb
+- lib/laforge/activerecord.rb
+- lib/laforge/version.rb
+- lib/tasks/laforge_tasks.rake
+homepage: https://github.com/combinaut/laforge
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: LaForge is a gem that makes it easy to build records using data from several
+  data sources
+test_files: []