lca 0.2.3 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 771b69813b99e5d0f92e8b69acd1a6c4b30014c8b1e6b6d253d60870bcf8b719
-  data.tar.gz: fe2d5c4335ea33f83d42d2997725b543c3c7fcb9d8e7c9057f023be92dea9264
+  metadata.gz: a16c5260b03c32b7338e2afc954b3b7e81cdac0d70281b381572cef31c4e2100
+  data.tar.gz: fb743e4d069c4768b3cb75fd8bd38774a5600148078e1d84bd7dc26e6686c351
 SHA512:
-  metadata.gz: 0b96260e9b0e79ca1b6add7b838adeb138d7ba0809271dd913f06759132a21145993cff3d30c55866f271160006d613b51d812417f8697d0550cd38a96f74009
-  data.tar.gz: e555dc61a62267987635e46bba1758134a8177d3fbf74ff769f746cc27d7b8ec175a8adc34b901d024a9cf8106c6051d4709fab09dfb81f423604f184372d259
+  metadata.gz: d0cb142ada744da2836415053fd8e5aa246463d2921dea9ad3b0f92aa1a6c88fe5e50fefdae34189ca6cee87a0bd664fdad47447737d364b1f39018518c3c517
+  data.tar.gz: 28bfb9f87f16d36ed059db06a4aa91de7d8b3390b2f49c3f69e74519958d093b64fbdfebb753e26fead95f8fe49aec7352742545f17559bed53e652ffe311316

data/README.md

@@ -4,10 +4,12 @@
 
 Storing, processing and working with life-cycle assessment data has always been challenging. A multitude of data models and implementations exist already but every one of them makes huge compromises or lacks functionality. 
 
-This gem implements a denormalized database model for life-cycle assessment data as well as several innovative query interfaces. 
+This gem implements a denormalized database model for life-cycle assessment data as well as several vectors for convenient querying. 
 
 ## Installation
 
+This gem is at home within a Rails 6+ console-only, API or full fledged application on top of a Postgres database.
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -42,42 +44,42 @@ Include the LCA concern into one of your models which will own lifecycle trees (
 This will extend your model and enable the following functionality:
 
 ```ruby
-    # query with ActiveRecord syntax
-    User.last.lca_cycles
-    User.find_by(name: "Acme").lca_cycles.impacts.select("impact_unit, sum(impact_amount) as total_impact").group(:impact_unit)
-    User.last.lca_cycles.where(...)
-    User.last.lca_cycles.where(...).group(...)
-    User.last.lca_cycles.where(...).limit(...).offset(...)
+# query with ActiveRecord syntax
+User.last.lca_cycles
+User.find_by(name: "Acme").lca_cycles.impacts.select("impact_unit, sum(impact_amount) as total_impact").group(:impact_unit)
+User.last.lca_cycles.where(...)
+User.last.lca_cycles.where(...).group(...)
+User.last.lca_cycles.where(...).limit(...).offset(...)
     
-    # AR query with ltree syntax
-    User.last.lca_cycles.disabled.match_path("*.CustomProcess.*")
-    User.last.lca_cycles.match_path("*{5,10}.CustomProcess.*.Ecosphere.*")
-    User.last.lca_cycles.active.match_path("*.WhateverProcess.*.Ecosphere.*.CO2Emission.*").where( impact_amount: [100..150]).sum(:impact_amount)
-
-    Lca::Cycle.match_path("Top.Electric Vehicle.*").impacts.match_path("*.CO2*").where( impact_amount: [ 1000..10000 ]).average(:impact_amount)
-    Lca::Cycle::Product.where(name: "Electric Vehicle Battery").impacts.match_path("*.Cobalt.*").sum(:impact_amount)
-    Lca::Process.where(owner: User.last).match_path("*{10,20}.*Assembly, automated.*")
-    Lca::Impact.match_path("*.Transport by truck.*")
-    Lca::Exchange.match_path("*.Oil.*.Ecosphere.*").impacts.sum(:impact_amount)
-    Lca::Product.match_path("*.ElectricVehicle.*").processes.match_path("*.Processing.*").where(location: "EU").impacts.match_path("*.Lithium.*").where(location: ["CN", "Africa"]).sum(:impact_amount)
+# AR query with ltree syntax
+User.last.lca_cycles.disabled.match_path("*.CustomProcess.*")
+User.last.lca_cycles.match_path("*{5,10}.CustomProcess.*.Ecosphere.*")
+User.last.lca_cycles.active.match_path("*.WhateverProcess.*.Ecosphere.*.CO2Emission.*").where( impact_amount: [100..150]).sum(:impact_amount)
+
+Lca::Cycle.match_path("Top.Electric Vehicle.*").impacts.match_path("*.CO2*").where( impact_amount: [ 1000..10000 ]).average(:impact_amount)
+Lca::Cycle::Product.where(name: "Electric Vehicle Battery").impacts.match_path("*.Cobalt.*").sum(:impact_amount)
+Lca::Process.where(owner: User.last).match_path("*{10,20}.*Assembly, automated.*")
+Lca::Impact.match_path("*.Transport by truck.*")
+Lca::Exchange.match_path("*.Oil.*.Ecosphere.*").impacts.sum(:impact_amount)
+Lca::Product.match_path("*.ElectricVehicle.*").processes.match_path("*.Processing.*").where(location: "EU").impacts.match_path("*.Lithium.*").where(location: ["CN", "Africa"]).sum(:impact_amount)
         
-    # pg_ltree queries
-    User.last.lca_cycles.last.parent
-    Lca::Process.match_path("*.Manual assembly.*").children
+# pg_ltree queries
+User.last.lca_cycles.last.parent
+Lca::Process.match_path("*.Manual assembly.*").children
     
-    # pg_ltree combined with AR syntax
-    User.last.lca_cycles(type: "Lca::Product").children.match_path("*.Retail").children.exchanges
+# pg_ltree combined with AR syntax
+User.last.lca_cycles(type: "Lca::Product").children.match_path("*.Retail").children.exchanges
     
-    # all queries can be directed to a specific partition:
-    Lca::Process.owned_by( owner_id ).match_path("*.Recycling.*").where(impact_unit: "tons CO2/year").impacts.sum(:impact_amount)
+# all queries can be directed to a specific partition:
+Lca::Process.owned_by( owner_id ).match_path("*.Recycling.*").where(impact_unit: "tons CO2/year").impacts.sum(:impact_amount)
     
 ```
 
 The gem also creates some default models:
 
 ```ruby
-    Lca::Process::Transport::ByAir.match_path("*.CO2Emission.*").impacts.sum(:impact_amount)
-    Lca::Impact::Ecosphere::Fauna.match_path("*.ResourceExtraction.*").where(impact_unit: "Species killed/year").sum(:impact_amount)
+Lca::Process::Transport::ByAir.match_path("*.CO2Emission.*").impacts.sum(:impact_amount)
+Lca::Impact::Ecosphere::Fauna.match_path("*.ResourceExtraction.*").where(impact_unit: "Species killed/year").sum(:impact_amount)
 ```
 
 To see what syntax to use for path traversal please check out the following resources:
@@ -88,14 +90,30 @@ The LCA gem is designed to be compatible with PostgREST. PostgREST is an amazing
 
 If the `create_postgrest_roles` setting is on each new owner will be assigned a Postgres role allowing them to access data within their partition using PostgREST. Your owner model will be extended with a `.generate_jwt` method you can use to generate the PostgREST authentication token.
 
+## Caveats
+
+`pg_ltree` .child / .parent queries do not work across different models due to an ActiveRecord limitation that requires results to be related via inheritance. 
+
+The following behaviors have been observed:
+
+```ruby
+
+Lca::Process.last.children.impacts.where(impact_amount: 50)
+# => nil
+
+Lca::Process.last.children.unscope(where: :type).impacts.where(impact_amount: 50)
+# => ActiveRecord::SubclassNotFound (Invalid single-table inheritance type: Lca::Impact is not a subclass of Lca::Process)
+```
+
 ## Roadmap
 
-* more models for various LCA cycles, processes and impacts
+* .child / .parent query support across models unrelated through inheritance 
+* more model templates for various LCA cycles, processes and impacts
 * model validations
-* query objects, including postgres RECURSIVE queries
+* query objects
+* postgres RECURSIVE queries
 * builders
 * seeds/fixtures
-* automated tests
 
 
 ## Contributing

data/lib/generators/lca/templates/migration.rb.tt

@@ -3,42 +3,53 @@ class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version
 
     # enable ltree extension
     begin
-        execute "create extension ltree"
+	execute "create extension ltree"
     rescue
-	   p "LTREE was already enabled"
+	p "LTREE was already enabled"
     end
+    
 
-    # LCA_OPTIONS[:table_name]
+    # create the main table as set up within LCA_OPTIONS[:table_name]
     execute <<-SQL
     create table #{ LCA_OPTIONS[:table_name] } (
 	id serial,
 
 	owner_id integer,
-    owner_type text,
+	owner_type character varying,
+	
+	status integer,
 
-	data_external_id text,
-	data_provider text,
+	data_external_id character varying,
+	data_provider character varying,
 
-	type text,
+	type character varying,
 	name text,
 
 	parent_entity_id integer,
-	parent_entity_type text,
+	parent_entity_type character varying,
 
 	path ltree,
     	path_slug text,
+    	
+    	metadata_inline jsonb,
 
 	impact_amount decimal,
+	impact_amount_previous decimal,
 	impact_amount_unit text,
 	impact_factor decimal,
 	impact_precision decimal,
+	
+	created_at timestamp(6) without time zone not null,
+	updated_at timestamp(6) without time zone not null,
+	
 
 	primary key (id, owner_id)
     ) partition by list(owner_id)
 SQL
 
-    # TODO do we want to also create an "others" partition?
-    # "CREATE TABLE #{LCA_OPTIONS[:table_name]}_others PARTITION OF #{LCA_OPTIONS[:table_name]} DEFAULT"
+    # create an "others" partition for when the owner is undefined/unknown? just in case / may help in some edge cases
+    execute "CREATE TABLE #{LCA_OPTIONS[:table_name]}_others PARTITION OF #{LCA_OPTIONS[:table_name]} DEFAULT"
+
 
     # add indexes
     add_index LCA_OPTIONS[:table_name], :id
@@ -50,6 +61,8 @@ SQL
     add_index LCA_OPTIONS[:table_name], :path, using: :gist
     add_index LCA_OPTIONS[:table_name], [:data_provider, :data_external_id]
 
+
+    # when postgrest is enabled...
     if LCA_OPTIONS[:create_postgrest_roles]
     	# create postgrest anon user with no privs
     	# postgrest may pass an user's role using JWT
@@ -57,5 +70,49 @@ SQL
     	execute "create role postgrest_anon nologin"
     	execute "grant postgrest_anon to #{ LCA_OPTIONS[:database_user] }"
     end
+
+
+    # snapshots table
+    # maybe this should only store the impacts?
+    execute <<-SQL
+    create table #{ LCA_OPTIONS[:table_name] }_snapshots (
+	id serial,
+
+	impact_id integer,
+	
+	owner_id integer,
+	owner_type character varying,
+
+	impact_amount decimal,
+	impact_amount_previous decimal,
+	impact_amount_unit text,
+	impact_factor decimal,
+	impact_precision decimal,
+
+	created_at timestamp(6) without time zone not null,
+	updated_at timestamp(6) without time zone not null,
+
+	primary key (id, owner_id)
+    ) partition by list(owner_id)
+SQL
+
+    # index the snapshots table
+    add_index "#{LCA_OPTIONS[:table_name]}_snapshots", :id
+    add_index "#{LCA_OPTIONS[:table_name]}_snapshots", :owner_id
+    add_index "#{LCA_OPTIONS[:table_name]}_snapshots", :impact_id
+    add_index "#{LCA_OPTIONS[:table_name]}_snapshots", :created_at
+
+
+    # metadata table
+    create_table "#{ LCA_OPTIONS[:table_name] }_metadata" do |t|
+	t.string :model_type
+	t.integer :model_id
+	t.string :key
+	t.text :value
+	
+	t.timestamps
+    end
+    add_index "#{ LCA_OPTIONS[:table_name] }_metadata", [ :model_type, :model_id ]
+    add_index "#{ LCA_OPTIONS[:table_name] }_metadata", [ :key ]
   end
 end

data/lib/lca/active_record.rb

@@ -1,6 +1,6 @@
-# this still needed?
 # we include the concern manually so there should be no need for this anymore
-ActiveSupport.on_load(:active_record) do
-    puts "tf is AR still being extended?"
-    extend Lca::Lcable
-end
+# besides, no need to polute other classes with our stuff.
+
+# ActiveSupport.on_load(:active_record) do
+#     extend Lca::Lcable
+# end

data/lib/lca/models/concerns/lcable.rb

@@ -1,18 +1,14 @@
 require "jwt"
 
+# read https://www.postgresqltutorial.com/postgresql-schema/
+
 module Lca
     module Lcable
     	extend ActiveSupport::Concern
 
-        # def self.included(base)
-        #     ::Lca::Model.class_exec do
-        #         @@owner_class = base.name
-        #     end
-        # end
-
         included do
 
-    	    has_many :lca_cycles, class_name: "::Lca::Cycle", foreign_key: :owner_id, as: :owner
+    	    has_many :lca_cycles, class_name: "::Lca::Model", foreign_key: :owner_id, as: :owner
     	    after_create :lca_create_storage
     	    before_destroy :lca_delete_storage
 
@@ -41,16 +37,21 @@ module Lca
         	    lca_sql "create table if not exists #{lca_table_name}_#{id} partition of #{lca_table_name} for values in (#{id})"
         	    # TODO create partition indexes
 
-                if LCA_OPTIONS[:create_postgrest_roles]
-            	    # drop role if it exists
-                    lca_sql "drop role if exists #{ lca_role }"
+        	    # create snapshots partition
+        	    lca_sql "create table if not exists #{lca_table_name}_snapshots_#{id} partition of #{lca_table_name}_snapshots for values in (#{id})"
+        	    # TODO create partition indexes
+
+            	    if LCA_OPTIONS[:create_postgrest_roles]
+            		# drop role if it exists
+                	lca_sql "drop role if exists #{ lca_role }"
 
-                    # create role
-            	    lca_sql "create role #{ lca_role }"
+                	# create role
+            		lca_sql "create role #{ lca_role }"
 
-        	        # grant privs
-        	        lca_sql "grant all privileges on #{lca_table_name}_#{id} to #{ lca_role }"
-                end
+        		# grant privs
+        		lca_sql "grant all privileges on #{lca_table_name}_#{id} to #{ lca_role }"
+        		lca_sql "grant all privileges on #{lca_table_name}_snapshots_#{id} to #{ lca_role }"
+            	    end
 
         	end # create_storage
 
@@ -58,21 +59,24 @@ module Lca
             # Deletes or detaches the partition and removes the role for this owner
         	def lca_delete_storage
 
-                if LCA_OPTIONS[:create_postgrest_roles]
+            	    if LCA_OPTIONS[:create_postgrest_roles]
         	        # revoke privs
         	        lca_sql "REVOKE ALL PRIVILEGES ON #{lca_table_name}_#{id} FROM #{ lca_role }"
+        	        lca_sql "REVOKE ALL PRIVILEGES ON #{lca_table_name}_snapshots_#{id} FROM #{ lca_role }"
 
         	        # delete role
         	        lca_sql "drop role #{ lca_role }"
-                end
+            	    end
 
-                if LCA_OPTIONS[:destroy_partition_on_owner_destroy]
+            	    if LCA_OPTIONS[:destroy_partition_on_owner_destroy]
         	        # delete partition
         	        lca_sql "drop table if exists #{lca_table_name}_#{id}"
-                else
-                    # detach and forget about it
-                    lca_sql "alter table #{lca_table_name} detach partition #{ lca_role }"
-                end
+        	        lca_sql "drop table if exists #{lca_table_name}_snapshots_#{id}"
+            	    else
+                	# detach and forget about it
+                	lca_sql "alter table #{lca_table_name} detach partition #{ lca_role }"
+                	lca_sql "alter table #{lca_table_name}_snapshots detach partition #{ lca_role }"
+            	    end
         	end # delete_storage
 
             def lca_sql sql

data/lib/lca/models/concerns/statusable.rb

@@ -13,8 +13,13 @@ module Lca::Statusable
 	alias_method :disable!, :inactive!
 	alias_method :off!, :inactive!
 	alias_method :toggle?, :toggle_status!
+	
+	before_create :set_default_status
     end
 
+    def set_default_status
+	self.status ||= 1
+    end
 
     def toggle_status!
         if active?

data/lib/lca/models/impact.rb

@@ -1,8 +1,18 @@
 class Lca::Impact < Lca::Model
     belongs_to :exchange, class_name: "::Lca::Exchange", foreign_key: :parent_entity_id, required: true
 
+    has_many :snapshots, class_name: "::Lca::ImpactSnapshot", foreign_key: :impact_id, dependent: :destroy
+
     validates_presence_of :impact_amount
     validates_presence_of :impact_amount_unit, allow_blank: false
     validates_presence_of :impact_factor
     validates_presence_of :impact_precision
+
+    # lol?
+    before_update :snapshot!
+
+
+    def take_snapshot!
+	return ::Lca::ImpactSnapshot.take! self
+    end # .snapshot!
 end

data/lib/lca/models/impact_snapshot.rb

@@ -0,0 +1,55 @@
+class Lca::ImpactSnapshot < ActiveRecord::Base
+
+    self.primary_key = :id
+
+    def self.table_name
+        return "#{::LCA_OPTIONS[:table_name]}_snapshots" if defined? ::LCA_OPTIONS
+        return "lca_models_snapshots"
+    end
+
+
+    belongs_to :impact, class_name: "::Lca::Impact", foreign_key: :impact_id, required: true
+    belongs_to :owner, polymorphic: true, required: true
+
+    validates_presence_of :impact_amount
+    validates_presence_of :impact_amount_unit, allow_blank: false
+    validates_presence_of :impact_factor
+    validates_presence_of :impact_precision
+
+
+
+    # pull data from owner's partition
+    def self.owned_by(owner_id)
+        return self if !owner_id.is_a? Integer
+        partition_suffix = "_#{owner_id}"
+        table = "#{ self.table_name }#{ partition_suffix }"
+
+        ApplicationRecord.connection.schema_cache.clear!
+        return self if !ApplicationRecord.connection.schema_cache.data_source_exists? table
+
+        model_class = Class.new self
+
+        original_class_name = self.name
+        class_name = "#{name}#{partition_suffix}"
+
+        model_class.define_singleton_method(:table_name) do
+            table
+        end
+
+        model_class.define_singleton_method(:name) do
+            class_name
+        end
+
+        model_class
+    end # owned_by
+
+
+    def self.take!(impact)
+	return create(
+	    impact.attributes
+		.deep_symbolize_keys
+		.slice(:impact_amount, :impact_amount_previous, :impact_amount_unit, :impact_factor, :impact_precision, :owner_id, :owner_type)
+		.merge( impact_id: impact.id )
+	)
+    end # .take!
+end

data/lib/lca/models/metadata.rb

@@ -0,0 +1,12 @@
+class Lca::Metadata < ActiveRecord::Base
+
+    belongs_to :model, polymorphic: true, required: true
+
+    def self.table_name
+	return "#{ ::LCA_OPTIONS[:table_name] }_metadata" if defined? ::LCA_OPTIONS
+	return "lca_models_metadata"
+    end
+    
+    validates_presence_of :key
+
+end

data/lib/lca/models/model.rb

@@ -4,6 +4,8 @@ class Lca::Model < ActiveRecord::Base
 
     self.primary_key = :id
 
+    ltree :path
+
     def self.table_name
         return ::LCA_OPTIONS[:table_name] if defined? ::LCA_OPTIONS
         return "lca_models"
@@ -19,10 +21,13 @@ class Lca::Model < ActiveRecord::Base
     validates_presence_of :name, allow_blank: false
     validates_presence_of :path, allow_blank: false
 
+    has_many :metadata, class_name: "::Lca::Metadata", dependent: :destroy, as: :model
+
     before_validation :set_defaults
     def set_defaults
-        self.path ||= name.parameterize.gsub("-", ".") if name
+        self.path ||= name.delete(" ").gsub(/[^0-9a-z ]/i, '') if name
         self.path_slug = path.parameterize if path
+        self.metadata_inline ||= {}
     end
 
 

data/lib/lca/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lca
-  VERSION = "0.2.3"
+  VERSION = "0.2.8"
 end

data/lib/lca.rb

@@ -3,15 +3,19 @@ require "active_support/all"
 
 require "active_record"
 
+require "pg_ltree"
+
 require_relative "lca/version"
 
 require_relative "lca/models/concerns/statusable"
+require_relative "lca/models/metadata"
 require_relative "lca/models/model"
 require_relative "lca/models/cycle"
 require_relative "lca/models/stage"
 require_relative "lca/models/process"
 require_relative "lca/models/exchange"
 require_relative "lca/models/impact"
+require_relative "lca/models/impact_snapshot"
 require_relative "lca/models/cycle/product"
 require_relative "lca/models/cycle/service"
 require_relative "lca/models/cycle/activity"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lca
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.8
 platform: ruby
 authors:
 - Nick @ Earthster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-25 00:00:00.000000000 Z
+date: 2021-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -118,6 +118,8 @@ files:
 - lib/lca/models/impact/human_health/cancer.rb
 - lib/lca/models/impact/technosphere.rb
 - lib/lca/models/impact/technosphere/resource_availability.rb
+- lib/lca/models/impact_snapshot.rb
+- lib/lca/models/metadata.rb
 - lib/lca/models/model.rb
 - lib/lca/models/process.rb
 - lib/lca/models/process/raw_resource.rb