fixtury 0.4.1 → 1.0.0.beta1

data/lib/fixtury/schema.rb

@@ -1,251 +1,47 @@
 # frozen_string_literal: true
 
-require "fixtury/definition"
-require "fixtury/path"
-require "fixtury/errors/already_defined_error"
-require "fixtury/errors/fixture_not_defined_error"
-require "fixtury/errors/schema_frozen_error"
-require "fixtury/errors/option_collision_error"
-
 module Fixtury
   class Schema
 
-    attr_reader :definitions, :children, :name, :parent, :relative_name, :around_fixture_definition, :options
-
-    def initialize(parent:, name:)
-      @name = name
-      @parent = parent
-      @relative_name = @name.split("/").last
-      @around_fixture_definition = nil
-      @options = {}
-      @frozen = false
-      reset!
-    end
-
-    def merge_options(opts = {})
-      opts.each_pair do |k, v|
-        if options.key?(k) && options[k] != v
-          raise ::Fixtury::Errors::OptionCollisionError.new(name, k, options[k], v)
-        end
-
-        options[k] = v
-      end
-    end
-
-    def around_fixture(&block)
-      @around_fixture_definition = block
-    end
-
-    def around_fixture_hook(executor, &definition)
-      maybe_invoke_parent_around_fixture_hook(executor) do
-        if around_fixture_definition.nil?
-          yield
-        else
-          around_fixture_definition.call(executor, definition)
-        end
-      end
-    end
-
-    def maybe_invoke_parent_around_fixture_hook(executor, &block)
-      return yield unless parent
-
-      parent.around_fixture_hook(executor, &block)
-    end
+    include ::Fixtury::SchemaNode
 
-    def reset!
-      @children = {}
-      @definitions = {}
+    def initialize(name: "", **options)
+      super(name: name, **options)
     end
 
-    def freeze!
-      @frozen = true
-    end
-
-    def frozen?
-      !!@frozen
-    end
-
-    def top_level_schema
-      top_level_schema? ? self : parent.top_level_schema
-    end
-
-    def top_level_schema?
-      parent.nil?
+    def acts_like_fixtury_schema?
+      true
     end
 
     def define(&block)
-      ensure_not_frozen!
       instance_eval(&block)
       self
     end
 
-    # helpful for inspection
-    def structure(indent = "")
-      out = []
-      out << "#{indent}ns:#{relative_name}"
-      definitions.keys.sort.each do |key|
-        out << "#{indent}  defn:#{key}"
-      end
-
-      children.keys.sort.each do |key|
-        child = children[key]
-        out << child.structure("#{indent}  ")
-      end
-
-      out.join("\n")
-    end
-
-    def namespace(name, options = {}, &block)
-      ensure_not_frozen!
-      ensure_no_conflict!(name: name, definitions: true, namespaces: false)
-
-      child = find_or_create_child_schema(name: name, options: options)
-      child.instance_eval(&block) if block_given?
-      child
-    end
-
-    def fixture(name, options = {}, &block)
-      ensure_not_frozen!
-      ensure_no_conflict!(name: name, definitions: true, namespaces: true)
-      create_child_definition(name: name, options: options, &block)
-    end
-
-    def enhance(name, &block)
-      ensure_not_frozen!
-      definition = get_definition!(name)
-      definition.enhance(&block)
-      definition
-    end
-
-    def merge(other_ns)
-      ensure_not_frozen!
-      other_ns.definitions.each_pair do |name, dfn|
-        fixture(name, dfn.options, &dfn.callable)
-        dfn.enhancements.each do |e|
-          enhance(name, &e)
-        end
-      end
-
-      other_ns.children.each_pair do |name, other_ns_child|
-        namespace(name, other_ns_child.options) do
-          merge(other_ns_child)
-        end
-      end
-
-      around_fixture(&other_ns.around_fixture_definition) if other_ns.around_fixture_definition
-
-      self
-    end
-
-    def get_definition!(name)
-      dfn = get_definition(name)
-      raise ::Fixtury::Errors::FixtureNotDefinedError, name unless dfn
-
-      dfn
-    end
-
-    def get_definition(name)
-      path = ::Fixtury::Path.new(namespace: self.name, path: name)
-      top_level = top_level_schema
-
-      dfn = nil
-      path.possible_absolute_paths.each do |abs_path|
-        *namespaces, definition_name = abs_path.split("/")
-
-        namespaces.shift if namespaces.first == top_level.name
-        target = top_level
-
-        namespaces.each do |ns|
-          next if ns.empty?
-
-          target = target.children[ns]
-          break unless target
-        end
-
-        dfn = target.definitions[definition_name] if target
-        return dfn if dfn
-      end
-
-      nil
+    def schema_node_type
+      first_ancestor? ? "schema" : "ns"
     end
 
-    def get_namespace(name)
-      path = ::Fixtury::Path.new(namespace: self.name, path: name)
-      top_level = top_level_schema
+    def namespace(name, **options, &block)
+      child = get("./#{name}")
 
-      path.possible_absolute_paths.each do |abs_path|
-        *namespaces, _definition_name = abs_path.split("/")
-
-        namespaces.shift if namespaces.first == top_level.name
-        target = top_level
-
-        namespaces.each do |ns|
-          next if ns.empty?
-
-          target = target.children[ns]
-          break unless target
-        end
-
-        return target if target
+      if child && !child.acts_like?(:fixtury_schema)
+        raise Errors::AlreadyDefinedError, child.pathname
       end
 
-      nil
-    end
-
-    protected
-
-    def find_child_schema(name:)
-      children[name.to_s]
-    end
-
-    def find_or_create_child_schema(name:, options:)
-      name = name.to_s
-      child = find_child_schema(name: name)
-      child ||= begin
-        children[name] = begin
-          child_name = build_child_name(name: name)
-          self.class.new(name: child_name, parent: self)
-        end
-      end
-      child.merge_options(options)
+      child ||= self.class.new(name: name, parent: self)
+      child.apply_options!(options)
+      child.instance_eval(&block) if block_given?
       child
     end
 
-    def find_child_definition(name:)
-      definitions[name.to_s]
-    end
-
-    def create_child_definition(name:, options:, &block)
-      child_name = build_child_name(name: name)
-      definition = ::Fixtury::Definition.new(name: child_name, schema: self, options: options, &block)
-      definitions[name.to_s] = definition
-    end
-
-    def build_child_name(name:)
-      name = name&.to_s
-      raise ArgumentError, "`name` must be provided" if name.nil?
-      raise ArgumentError, "#{name} is invalid. `name` must contain only a-z, A-Z, 0-9, and _." unless /^[a-zA-Z_0-9]+$/.match?(name)
-
-      arr = ["", self.name, name]
-      arr.join("/").gsub(%r{/{2,}}, "/")
-    end
-
-    def ensure_no_conflict!(name:, namespaces:, definitions:)
-      if definitions
-        definition = find_child_definition(name: name)
-        raise ::Fixtury::Errors::AlreadyDefinedError, definition.name if definition
-      end
-
-      if namespaces
-        ns = find_child_schema(name: name)
-        raise ::Fixtury::Errors::AlreadyDefinedError, ns.name if ns
-      end
-    end
-
-    def ensure_not_frozen!
-      return unless frozen?
-
-      raise ::Fixtury::Errors::SchemaFrozenError
+    def fixture(name, **options, &block)
+      ::Fixtury::Definition.new(
+        name: name,
+        parent: self,
+        **options,
+        &block
+      )
     end
 
   end

data/lib/fixtury/schema_node.rb

@@ -0,0 +1,113 @@
+module Fixtury
+  module SchemaNode
+
+    extend ActiveSupport::Concern
+
+    VALID_NODE_NAME = /^[a-zA-Z0-9_]*$/
+
+    included do
+      attr_reader :name, :pathname, :parent, :children, :options
+    end
+
+    def initialize(name:, parent: nil, **options)
+      name = name.to_s
+      raise ArgumentError, "#{name.inspect} is an invalid node name" unless name.match?(VALID_NODE_NAME)
+
+      @name = name
+      @parent = parent
+      @pathname = File.join(*[parent&.pathname, "/", @name].compact).to_s
+      @children = {}
+      @options = {}
+      apply_options!(options)
+      @parent.add_child(self) if @parent
+    end
+
+    def inspect
+      "#{self.class}(pathname: #{pathname.inspect}, children: #{children.size})"
+    end
+
+    def schema_node_type
+      raise NotImplementedError
+    end
+
+    def acts_like_fixtury_schema_node?
+      true
+    end
+
+    def first_ancestor
+      first_ancestor? ? self : parent.first_ancestor
+    end
+
+    def add_child(child)
+      if children.key?(child.name) && children[child.name] != child
+        raise Errors::AlreadyDefinedError, child.pathname
+      end
+
+      children[child.name] = child
+    end
+
+    def first_ancestor?
+      parent.nil?
+    end
+
+    def isolation_key(default: true)
+      from_parent = parent&.isolation_key(default: nil)
+      return from_parent if from_parent
+
+      value = options[:isolate] || default
+      value = (value == true ? pathname : value&.to_s).presence
+      value == "/" ? nil : value # special case to accommodate root nodes
+    end
+
+    def get!(search)
+      thing = get(search)
+      raise Errors::SchemaNodeNotDefinedError.new(pathname, search) unless thing
+
+      thing
+    end
+
+    def get(search)
+      raise ArgumentError, "`search` must be provided" if search.blank?
+
+      resolver = Fixtury::PathResolver.new(namespace: self.pathname, search: search)
+      resolver.possible_absolute_paths.each do |path|
+        target = first_ancestor
+        segments = path.split("/")
+        segments.reject!(&:blank?)
+        segments.shift if segments.first == target.name
+        segments.each do |segment|
+          target = target.children[segment]
+          break unless target
+        end
+
+        return target if target
+      end
+
+      nil
+    end
+    alias [] get
+
+    # helpful for inspection
+    def structure(prefix = "")
+      out = []
+      my_structure = +"#{prefix}#{schema_node_type}:#{name}"
+      my_structure << "(#{options.inspect})" if options.present?
+      out << my_structure
+      children.each_value do |child|
+        out << child.structure("#{prefix}  ")
+      end
+      out.join("\n")
+    end
+
+    def apply_options!(opts = {})
+      opts.each do |key, value|
+        if options.key?(key) && options[key] != value
+          raise Errors::OptionCollisionError.new(name, key, options[key], value)
+        end
+
+        options[key] = value
+      end
+    end
+
+  end
+end

data/lib/fixtury/store.rb

@@ -3,33 +3,36 @@
 require "fileutils"
 require "singleton"
 require "yaml"
-require "fixtury/locator"
-require "fixtury/errors/circular_dependency_error"
-require "fixtury/reference"
 
 module Fixtury
   class Store
 
-    cattr_accessor :instance
-
-    attr_reader :filepath, :references, :ttl, :auto_refresh_expired
-    attr_reader :schema, :locator
+    attr_reader :filepath
+    attr_reader :loaded_isolation_keys
+    attr_reader :locator
     attr_reader :log_level
+    attr_reader :references
+    attr_reader :schema
+    attr_reader :ttl
 
-    def initialize(
-      filepath: nil,
-      locator: ::Fixtury::Locator.instance,
-      ttl: nil,
-      schema: nil,
-      auto_refresh_expired: false
-    )
+    def initialize(filepath: nil, locator: nil, ttl: nil, schema: nil)
       @schema = schema || ::Fixtury.schema
-      @locator = locator
+      @locator = locator || ::Fixtury::Locator.new
       @filepath = filepath
-      @references = @filepath && ::File.file?(@filepath) ? ::YAML.load_file(@filepath) : {}
-      @ttl = ttl ? ttl.to_i : ttl
-      @auto_refresh_expired = !!auto_refresh_expired
-      self.class.instance ||= self
+      @references = load_reference_from_file || {}
+      @ttl = ttl&.to_i
+      @loaded_isolation_keys = {}
+    end
+
+    def inspect
+      parts = []
+      parts << "schema: #{schema.inspect}"
+      parts << "locator: #{locator.inspect}"
+      parts << "filepath: #{filepath.inspect}" if filepath
+      parts << "ttl: #{ttl.inspect}" if ttl
+      parts << "references: #{references.size}"
+
+      "#{self.class}(#{parts.join(", ")})"
     end
 
     def dump_to_file
@@ -37,36 +40,40 @@ module Fixtury
 
       ::FileUtils.mkdir_p(File.dirname(filepath))
 
-      writable = references.each_with_object({}) do |(full_name, ref), h|
-        h[full_name] = ref if ref.real?
+      writable = references.each_with_object({}) do |(pathname, ref), h|
+        h[pathname] = ref if ref.real?
       end
 
-      ::File.open(filepath, "wb") { |io| io.write(writable.to_yaml) }
+      ::File.binwrite(filepath, writable.to_yaml)
+    end
+
+    def load_reference_from_file
+      return unless filepath
+      return unless File.file?(filepath)
+
+      ::YAML.unsafe_load_file(filepath)
     end
 
-    def clear_expired_references!
+    def clear_stale_references!
       return unless ttl
 
       references.delete_if do |name, ref|
-        is_expired = ref_invalid?(ref)
-        log("expiring #{name}", level: LOG_LEVEL_DEBUG) if is_expired
-        is_expired
+        stale = reference_stale?(ref)
+        log("expiring #{name}", level: LOG_LEVEL_DEBUG) if stale
+        stale
       end
     end
 
     def load_all(schema = self.schema)
-      schema.definitions.each_pair do |_key, dfn|
-        get(dfn.name)
-      end
-
-      schema.children.each_pair do |_key, ns|
-        load_all(ns)
+      schema.children.each_value do |item|
+        get(item.name) if item.acts_like?(:fixtury_definition)
+        load_all(item) if item.acts_like?(:fixtury_schema)
       end
     end
 
     def clear_cache!(pattern: nil)
       pattern ||= "*"
-      pattern = "/" + pattern unless pattern.start_with?("/")
+      pattern = "/#{pattern}" unless pattern.start_with?("/")
       glob = pattern.end_with?("*")
       pattern = pattern[0...-1] if glob
       references.delete_if do |key, _value|
@@ -86,73 +93,111 @@ module Fixtury
     end
 
     def loaded?(name)
-      dfn = schema.get_definition!(name)
-      full_name = dfn.name
-      ref = references[full_name]
+      dfn = schema.get!(name)
+      ref = references[dfn.pathname]
       result = ref&.real?
-      log(result ? "hit #{full_name}" : "miss #{full_name}", level: LOG_LEVEL_ALL)
+      log(result ? "hit #{dfn.pathname}" : "miss #{dfn.pathname}", level: LOG_LEVEL_ALL)
       result
     end
 
-    def get(name, execution_context: nil)
-      dfn = schema.get_definition!(name)
-      full_name = dfn.name
-      ref = references[full_name]
+    def loaded_or_loading?(pathname)
+      !!references[pathname]
+    end
+
+    def maybe_load_isolation_dependencies(definition)
+      isolation_key = definition.isolation_key
+      return if loaded_isolation_keys[isolation_key]
 
+      load_isolation_dependencies(isolation_key, schema.first_ancestor)
+    end
+
+    def load_isolation_dependencies(isolation_key, target_schema)
+      loaded_isolation_keys[isolation_key] = true
+      target_schema.children.each_value do |child|
+        if child.acts_like?(:fixtury_definition)
+          next unless child.isolation_key == isolation_key
+          next if loaded_or_loading?(child.pathname)
+          get(child.pathname)
+        elsif child.acts_like?(:fixtury_schema)
+          load_isolation_dependencies(isolation_key, child)
+        else
+          raise NotImplementedError, "Unknown isolation loading behavior: #{child.class.name}"
+        end
+      end
+    end
+
+    # Fetch a fixture by name. This will load the fixture if it has not been loaded yet.
+    # If a definition contains an isolation key, all fixtures with the same isolation key will be loaded.
+    def get(name)
+      log("getting #{name}", level: LOG_LEVEL_DEBUG)
+
+      # Find the definition.
+      dfn = schema.get!(name)
+      raise ArgumentError, "#{name.inspect} must refer to a definition" unless dfn.acts_like?(:fixtury_definition)
+
+      pathname = dfn.pathname
+
+      # Ensure that if we're part of an isolation group, we load all the fixtures in that group.
+      maybe_load_isolation_dependencies(dfn)
+
+      # See if we already hold a reference to the fixture.
+      ref = references[pathname]
+
+      # If the reference is a placeholder, we have a circular dependency.
       if ref&.holder?
-        raise ::Fixtury::Errors::CircularDependencyError, full_name
+        raise Errors::CircularDependencyError, pathname
       end
 
-      if ref && auto_refresh_expired && ref_invalid?(ref)
-        log("refreshing #{full_name}", level: LOG_LEVEL_DEBUG)
-        clear_ref(full_name)
+      # If the reference is stale, we should refresh it.
+      # We do so by clearing it from the store and setting the reference to nil.
+      if ref && reference_stale?(ref)
+        log("refreshing #{pathname}", level: LOG_LEVEL_DEBUG)
+        clear_reference(pathname)
         ref = nil
       end
 
       value = nil
 
       if ref
-        log("hit #{full_name}", level: LOG_LEVEL_ALL)
-        value = load_ref(ref.value)
+        log("hit #{pathname}", level: LOG_LEVEL_ALL)
+        value = locator.load(ref.locator_key)
         if value.nil?
-          clear_ref(full_name)
-          log("missing #{full_name}", level: LOG_LEVEL_ALL)
+          clear_reference(pathname)
+          ref = nil
+          log("missing #{pathname}", level: LOG_LEVEL_ALL)
         end
       end
 
       if value.nil?
         # set the references to a holder value so any recursive behavior ends up hitting a circular dependency error if the same fixture load is attempted
-        references[full_name] = ::Fixtury::Reference.holder(full_name)
-
-        value = dfn.call(store: self, execution_context: execution_context)
+        references[pathname] = ::Fixtury::Reference.holder(pathname)
+
+        begin
+          executor = ::Fixtury::DefinitionExecutor.new(store: self, definition: dfn)
+          value = executor.call
+        rescue StandardError
+          clear_reference(pathname)
+          raise
+        end
 
-        log("store #{full_name}", level: LOG_LEVEL_DEBUG)
+        log("store #{pathname}", level: LOG_LEVEL_DEBUG)
 
-        ref = dump_ref(full_name, value)
-        ref = ::Fixtury::Reference.new(full_name, ref)
-        references[full_name] = ref
+        locator_key = locator.dump(value, context: pathname)
+        references[pathname] = ::Fixtury::Reference.new(pathname, locator_key)
       end
 
       value
     end
     alias [] get
 
-    def load_ref(ref)
-      locator.load(ref)
-    end
-
-    def dump_ref(_name, value)
-      locator.dump(value)
-    end
-
-    def clear_ref(name)
-      references.delete(name)
+    def clear_reference(pathname)
+      references.delete(pathname)
     end
 
-    def ref_invalid?(ref)
+    def reference_stale?(ref)
       return true if ttl && ref.created_at < (Time.now.to_i - ttl)
 
-      !locator.recognize?(ref.value)
+      !locator.recognizable_key?(ref.locator_key)
     end
 
     def log(msg, level:)