ymodel 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb2619f40ddda987fd2634ac4a76cd6622856ac0c2797dcf05853de00f6e8894
-  data.tar.gz: 81188efca59a5169ff6a74b25473e35aa87407c2080b9125b1a13739c9b1e964
+  metadata.gz: 3e76b055a94aca7267be60ff8727343c1cacdbee176df49d0b757c63678c3703
+  data.tar.gz: 279c251a3f1bc448b4ca013ead8bee6eb2a3356f197b415360d099ea16a33762
 SHA512:
-  metadata.gz: 866c550c19239e4ca5c64be3d50fce87c18d3e4a41d9d0298b2d271dd09923e9edcaef4278d01330bddde83e0fb6ec9aadaced36a0f66e800f2e54700639aeb4
-  data.tar.gz: c6056b25f8809ab20a30d15625fb8f811e4e3e8fb95b79b5c1d17cdf5bd1e92ef2a7b0d8f7f066fe2174de54a6f35dd1e960b7f282dfd5a94d83c563c7966f97
+  metadata.gz: 9065024111d3d97779cc30566e08d14d118f797ace4c9bfc869255ed5558f7078601fe95bfaaeb1b7a1c3079fefab5b64db48f3c593ddddaee7ecc942a44663f
+  data.tar.gz: 45228ad8ac261538e73b064544780cf4b96036a95e75f1860af99d91e61226c6eea0806079e3ac9b79740552ba9993862952beba52740bc58fafcf324dbef7ba

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    ymodel (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    rake (13.0.6)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+
+PLATFORMS
+  arm64-darwin-20
+
+DEPENDENCIES
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  ymodel!
+
+BUNDLED WITH
+   2.3.14

data/README.md

@@ -1,8 +1,6 @@
 # Ymodel
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ymodel`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Welcome to ymodel. An active-record-like interface to wrap yaml files.
 
 ## Installation
 
@@ -16,7 +14,61 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+Create a model with data from Yaml files:
+
+```ruby
+class GridCode < YModel::Base
+  index_on :name
+
+  default_attribute :successful_outcomes, with: []
+  default_attribute :loading_outcomes, with: []
+  default_attribute :loading_maximum, with: 0
+  default_attribute :required_documents, with: []
+end
+```
+
+```yaml
+---
+data:
+  - name: FM1
+    successful_questionnaire_outcomes:
+      - standard
+      - accord
+    loading_outcomes:
+      - majoration
+    loading_maximum: 50
+    questionnaire_type: QSS
+    priority: 1
+
+  - name: FM2
+    successful_questionnaire_outcomes:
+      - standard
+      - accord
+    loading_outcomes:
+      - majoration
+    loading_maximum: 50
+    questionnaire_type: QM
+    priority: 1
+
+  - name: FM3
+    questionnaire_type: QM
+    priority: 2
+    required_documents:
+      - BIO 1
+```
+
+```irb
+3.0.1 :001 > GridCode.all.first
+ =>
+#<GridCode:0x000000011a0b7640
+ @loading_maximum=50,
+ @loading_outcomes=["majoration"],
+ @name="FM1",
+ @priority=1,
+ @questionnaire_type="QSS",
+ @required_documents=[],
+ @successful_questionnaire_outcomes=["standard", "accord"]>
+```
 
 ## Development
 
@@ -26,7 +78,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ymodel.
+Suggestions, ideas or contribution can be discussed with steven@remarkgroup.com.
 
 ## License
 

data/lib/ymodel/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'relatable'
+require_relative 'loadable'
+require_relative 'triggerable'
+require_relative 'queryable'
+
+module Ymodel
+  # This is used to wrap a YAML file in a similar manner to ActiveRecord
+  # wrapping a database.
+  class Base
+    extend Ymodel::Relatable
+    extend Ymodel::Loadable
+    extend Ymodel::Triggerable
+    extend Ymodel::Queryable
+
+    def initialize(record = {})
+      record.each do |k, v|
+        instance_variable_set "@#{k}", v if attribute?(k)
+      end
+    end
+
+    def ==(other)
+      other.respond_to?(:attributes) && attributes == other.attributes
+    end
+
+    def attributes
+      # definitive schema
+      schema.attributes
+        .each_with_object({}) { |attr, memo| memo[attr] = send(attr) }
+    end
+
+    def [](property)
+      instance_variable_get("@#{property}")
+    end
+
+    def attribute?(key)
+      # definitive schema
+      schema.include?(key) || key == :id
+    end
+
+    def index
+      self[index_key]
+    end
+
+    private
+
+    def schema
+      self.class.schema
+    end
+
+    def index_key
+      self.class.instance_variable_get('@index') || :id
+    end
+
+    def index_set?
+      # The name of the key of the index is stored as an instance variable in
+      # the class.
+      index = self.class.instance_variable_get('@index') || :id
+      self[index]
+    end
+  end
+end

data/lib/ymodel/errors.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/Documentation
+module Ymodel
+  module Errors; end
+
+  class YmodelError < StandardError
+  end
+
+  class SourceFileNotFound < YmodelError
+    attr_reader :model
+
+    def initialize(message = nil, model = nil)
+      @model = model
+
+      super(message)
+    end
+  end
+
+  class MissingConstant < YmodelError
+  end
+
+  class UnacceptableOptionsError < YmodelError
+  end
+
+  class UnpermittedParamsError < YmodelError
+  end
+
+  class RecordNotFound < YmodelError
+  end
+
+  class DuplicateIndexError < YmodelError
+  end
+end
+# rubocop:enable Style/Documentation

data/lib/ymodel/helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ymodel
+  # This module contains YModel logic for managing relations.
+  module Helper
+    def self.model_class(model)
+      as_const = model.to_s.singularize.camelcase
+      Kernel.const_get(as_const)
+    rescue StandardError
+      message = "relation `#{model}` couldn't be made because constant "\
+                "`#{as_const}` doesn't exist."
+      raise Ymodel::MissingConstant, message
+    end
+  end
+end

data/lib/ymodel/loadable.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'schema'
+
+module Ymodel
+  # Module resposible for loading the schema and data from the yaml files.
+  module Loadable
+    # This method can be called from within a concrete implementation to
+    # overwrite the default ymodel filename associated with that model.
+    def source_file(filename)
+      @source = filename
+
+      # Similar to Trigger#inherited. A hook for loading the schema.
+      define_readers self
+    end
+
+    def pears_subject(subject)
+      @pears = true
+      if block_given?
+        @source = Pears.subject(subject) { |provider| yield(provider) }
+      else
+        @source = subject
+      end
+      # Similar to Trigger#inherited. A hook for loading the schema.
+      define_readers self
+    end
+
+    # With is used as the default value of the attribute
+    def default_attribute(attr_name, with: nil)
+      @schema << attr_name
+      define_reader attr_name, default: with
+    end
+
+    def schema
+      @schema = Schema.new(records, index)
+      if @manual_index
+        @schema ||= Schema.new(records)
+      else
+        @schema ||= Schema.new(records, :id)
+      end
+    rescue Errno::ENOENT => e
+      Schema.new({})
+    end
+
+    def load_records!
+      if load_indices?
+        all = records.each_with_index
+            .map { |record, i| new(record.merge({id: i})) }
+      else
+        all = records.map { |record| new(record) }
+      end
+      unless all.map(&:index) == all.map(&:index).uniq
+        raise DuplicateIndexError,
+              "#{name}: Some records share the same index"
+      end
+
+      all
+    end
+
+    def index_on(key)
+      @manual_index = true
+      @index = key
+    end
+
+    def index
+      @index || :id
+    end
+
+    def source_files
+      if compiled?
+        Dir.glob(File.join(source, '*.yml'))
+      else
+        [@source]
+      end
+    end
+
+    def define_reader(attribute, default: nil)
+      define_method(attribute.to_sym) do
+        value = instance_variable_get("@#{attribute}")
+        if value.nil? && !default.nil?
+          value = instance_variable_set(
+            "@#{attribute}",
+            default.respond_to?(:call) ? default.call : default
+          )
+        end
+
+        value
+      end
+    end
+
+    protected
+
+    def records
+      if @pears
+        @source[:data]
+      else
+        @records ||= source_files.flat_map { |name| YAML.load_file(name) }
+            .map(&:symbolize_keys)
+      end
+    end
+
+    def source
+      @source ||= _source
+    end
+
+    private
+
+    def load_indices?
+      index == :id && !@manual_index
+    end
+
+    def compiled?
+      File.directory?(File.join(Rails.root, source))
+    end
+
+    def _source
+      File.join(Rails.root,
+                'config',
+                'ymodel',
+                name.gsub('::', '/').pluralize.underscore + '.yml')
+    end
+
+    def load_index=(value)
+      @load_index = value
+    end
+  end
+end

data/lib/ymodel/queryable.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Ymodel
+  # This mixin holds the query methods.
+  module Queryable
+    def find(index)
+      all.find { |record| record.index == index }
+    end
+
+    def find!(index)
+      find(index) || raise_record_not_found_exception!(index)
+    end
+
+    def find_by(attributes)
+      sanitized = sanitize_attributes(attributes)
+      all.each do |record|
+        return record if sanitized.all? { |k, v| record.send(k) == v }
+      end
+
+      nil
+    end
+
+    def find_by!(attributes)
+      find_by(attributes) || raise_record_not_found_exception!(attributes)
+    end
+
+    def find_by_key(key)
+      all.find do |record|
+        record.key == key.to_s
+      end
+    end
+
+    def find_by_key!(key)
+      find_by_key(key) || raise_record_not_found_exception!(key)
+    end
+
+    def all
+      if @pears
+        load_records!
+      else
+        @all ||= load_records!
+      end
+    rescue Errno::ENOENT
+      raise SourceFileNotFound
+    end
+
+    def where(attributes)
+      sanitized = sanitize_attributes(attributes)
+
+      if sanitized.length != attributes.length
+        unpermitted = (attributes.keys.map(&:to_sym) - sanitized.keys)
+        message = "These attributes are not allowed: #{unpermitted}"
+
+        raise UnpermittedParamsError, message
+      end
+
+      all.select do |record|
+        sanitized.all? { |key, value| record.send(key) == value }
+      end
+    end
+
+    # Beware of using this method. If all attributes get removed during
+    # sanitation it returns the equivalent of #all.
+    def where!(attributes)
+      sanitized = sanitize_attributes(attributes)
+      all.select do |record|
+        sanitized.all? { |key, value| record.send(key) == value }
+      end
+    end
+
+    def sanitize_attributes(attributes)
+      # definitive schema
+      attributes.symbolize_keys!
+        .select { |attr| schema.include?(attr) }
+    end
+
+    def raise_record_not_found_exception!(attributes = nil)
+      if attributes.is_a?(Hash)
+        message = "Couldn't find #{name} with "
+        attributes.each { |k, v| message += "#{k}: #{v}" }
+      else
+        message = "Couldn't find #{name} #{attributes}"
+      end
+      raise RecordNotFound, message
+    end
+  end
+end

data/lib/ymodel/relatable.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require_relative 'helper'
+
+module Ymodel
+  # This module contains YModel logic for managing relations.
+  module Relatable
+    # This method is used to define the key on which relations are build.
+    # We default to 'id'.
+
+    def belongs_to(model, options = {})
+      define_method(model) do
+        related_class =
+          Helper.model_class(options[:class_name] || model)
+        key =
+          if related_class < Base
+            :"#{model.to_s.singularize}_#{related_class.index}"
+          else
+            :"#{related_class.to_s.singularize}_id"
+          end
+        related_class.find(self[key])
+      end
+    end
+
+    # rubocop:disable Naming/PredicateName
+    # rubocop:disable Naming/UncommunicativeMethodParamName
+    def has_many(model, class_name: nil, as: nil, foreign_key: nil)
+      raise_options_error if as && foreign_key
+
+      foreign_key ||= default_foreign_key
+      define_method(model) do
+        relation_class = Helper.model_class(class_name || model)
+        if as
+          relation_class.where("#{as}_id" => id,
+                               "#{as}_type" => self.class.name)
+        else
+          relation_class.where(foreign_key.to_sym => index)
+        end
+      end
+    end
+
+    def has_one(model, class_name: nil, as: nil, foreign_key: nil)
+      raise_options_error if as && foreign_key
+
+      foreign_key ||= default_foreign_key
+      define_method(model) do
+        relation_class = Helper.model_class(class_name || model)
+        return relation_class.find_by(foreign_key => index) unless as
+
+        relation_class.find_by("#{as}_id" => id,
+                               "#{as}_type" => self.class.name)
+      end
+    end
+    # rubocop:enable Naming/PredicateName
+    # rubocop:enable Naming/UncommunicativeMethodParamName
+
+    private
+
+    def default_foreign_key
+      "#{name.to_s.underscore.singularize}_#{index}"
+    end
+
+    def raise_options_error
+      raise UnacceptableOptionsError, "Relations with an 'as' and"\
+          " 'foreign_key' are not supported."
+    end
+  end
+end

data/lib/ymodel/schema.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Ymodel
+  # Represents a schema of all keys found in the source.
+  class Schema
+    extend Forwardable
+    include Enumerable
+    attr_reader :attributes
+
+    def_delegators :attributes, :each
+
+    def initialize(source, *keys)
+      @attributes = source.flat_map(&:keys)
+          .map(&:to_sym)
+          .to_set + keys
+    end
+
+    def include?(key)
+      attributes.include?(key.to_sym)
+    end
+
+    def <<(attribute)
+      @attributes << attribute.to_sym
+    end
+  end
+end

data/lib/ymodel/triggerable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ymodel
+  # Handles events that decorate the instances with methods.
+  module Triggerable
+    protected
+
+    def define_readers(model)
+      model.instance_eval do
+        schema.attributes.each { |attribute| define_reader(attribute) }
+      end
+    end
+
+    private
+
+    def inherited(model)
+      define_readers(model)
+      @triggered = true
+    end
+  end
+end

data/lib/ymodel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ymodel
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/ymodel.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "ymodel/version"
+require_relative "ymodel/base"
 
 module Ymodel
+
   class Error < StandardError; end
   # Your code goes here...
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ymodel
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Steven Kemp
@@ -20,10 +20,19 @@ files:
 - ".rspec"
 - CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/ymodel.rb
+- lib/ymodel/base.rb
+- lib/ymodel/errors.rb
+- lib/ymodel/helper.rb
+- lib/ymodel/loadable.rb
+- lib/ymodel/queryable.rb
+- lib/ymodel/relatable.rb
+- lib/ymodel/schema.rb
+- lib/ymodel/triggerable.rb
 - lib/ymodel/version.rb
 - sig/ymodel.rbs
 homepage: