risa 1.0.0

data/lib/risa/context.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require_relative 'relations'
+
+module Risa
+  class DefinitionContext
+    include Risa::Relations::DSL
+
+    attr_reader :loaded_data, :scopes
+
+    def initialize(model_name, data_path)
+      @model_name = model_name
+      @data_path = data_path
+      @loaded_data = []
+      @scopes = {}
+      @relations = {}
+    end
+
+    def load(pattern)
+      file_pattern = File.join(@data_path, pattern)
+      files = Dir[file_pattern].sort
+      
+      raise DataFileError, "No files found matching pattern: #{file_pattern}" if files.empty?
+      
+      @loaded_data = files.map do |file|
+        begin
+          hash_data = eval(File.read(file), TOPLEVEL_BINDING, file)
+          
+          unless hash_data.is_a?(::Hash)
+            raise DataFileError, "#{file} should return a Hash, but returned #{hash_data.class}"
+          end
+          
+          hash_data.freeze
+        rescue DataFileError => e
+          raise e
+        rescue SyntaxError => e
+          raise DataFileError, "#{file} has a syntax error:\n#{e.message}"
+        rescue => e
+          raise DataFileError, "#{file} couldn't be loaded:\n#{e.message}"
+        end
+      end
+    end
+
+    def from_array(array)
+      unless array.is_a?(Array)
+        raise DataFileError, "from_array() expects an Array of hashes, but got #{array.class}"
+      end
+      
+      @loaded_data = array.map.with_index do |item, index|
+        unless item.is_a?(::Hash)
+          raise DataFileError, "from_array() array item #{index + 1} should be a Hash, but got #{item.class}"
+        end
+        item.freeze
+      end
+    end
+
+    def scope(methods_hash)
+      methods_hash.each do |name, lambda_proc|
+        unless lambda_proc.respond_to?(:call)
+          raise ScopeError, "Scope #{name} must be callable (lambda or proc)"
+        end
+        @scopes[name.to_sym] = lambda_proc
+      end
+    end
+  end
+end

data/lib/risa/instance.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require_relative 'relations'
+
+module Risa
+  class InstanceWrapper
+    include Risa::Relations::Fetcher
+    RESERVED_METHODS = [
+      :class, :object_id, :hash, :to_s, :inspect, :nil?, :frozen?, 
+      :clone, :dup, :taint, :untaint, :freeze, :equal?, :==, :===,
+      :send, :public_send, :respond_to?, :method, :methods,
+      :instance_variables, :instance_variable_get, :instance_variable_set,
+      :instance_of?, :kind_of?, :is_a?, :to_h, :to_hash
+    ].freeze
+
+    def initialize(hash, model_name)
+      @_hash = hash
+      @_memoized = {}
+      @_model_name = model_name
+      @_relations = Risa.relations_for(@_model_name)
+      @_presenter_module = Risa.presenter_for(@_model_name)
+
+      @_hash.each_key do |key|
+        method_name = key.to_sym
+        next if RESERVED_METHODS.include?(method_name)
+        
+        define_singleton_method(method_name) do
+          @_hash[key]
+        end
+      end
+
+      @_relations.each_key do |relation_name|
+        define_singleton_method(relation_name) do
+          fetch_relation(relation_name)
+        end
+      end
+
+      if @_presenter_module
+        @_presenter_module.instance_methods(false).each do |method_name|
+          original_method = @_presenter_module.instance_method(method_name)
+          
+          define_singleton_method(method_name) do |*args, &block|
+            cache_key = [method_name, args]
+            
+            unless @_memoized.key?(cache_key)
+              begin
+                @_memoized[cache_key] = original_method.bind(self).call(*args, &block)
+              rescue => e
+                raise Risa::ItemMethodError,
+                      "Error executing presenter method :#{method_name} on #{@_model_name} instance #{@_hash.inspect}: #{e.message}\n  #{e.backtrace&.first}"
+              end
+            end
+            
+            @_memoized[cache_key]
+          end
+        end
+      end
+    end
+
+    def [](key)
+      @_hash&.[](key.to_sym) || @_hash&.[](key)
+    end
+
+    def []=(key, value)
+      raise "Risa::InstanceWrapper collections are immutable. Cannot assign #{key} = #{value}"
+    end
+
+    def respond_to?(method_name, include_private = false)
+      symbol_name = method_name.to_sym
+      return true if singleton_class.method_defined?(symbol_name)
+      return true if @_presenter_module&.method_defined?(symbol_name)
+      return true if @_hash&.key?(symbol_name) && !RESERVED_METHODS.include?(symbol_name)
+      return true if @_relations&.key?(symbol_name)
+      super
+    end
+
+    def inspect
+      "#<Risa::Instance #{@_hash.inspect}>"
+    end
+
+    def to_h
+      @_hash
+    end
+
+    def to_hash
+      @_hash
+    end
+  end
+end

data/lib/risa/page.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Risa
+  class Page
+    attr_reader :items, :current_page, :total_pages, :total_items,
+                :prev_page, :next_page, :is_first_page, :is_last_page
+    
+    def initialize(items, current_page, total_pages, total_items)
+      @items = items
+      @current_page = current_page
+      @total_pages = total_pages
+      @total_items = total_items
+      @prev_page = current_page > 1 ? current_page - 1 : nil
+      @next_page = current_page < total_pages ? current_page + 1 : nil
+      @is_first_page = current_page == 1
+      @is_last_page = current_page == total_pages
+    end
+    
+    # Aliases for consistency with your SSG (e.g., 'posts' instead of 'items')
+    alias_method :posts, :items
+    
+    def to_h
+      {
+        items: @items,
+        current_page: @current_page,
+        total_pages: @total_pages,
+        total_items: @total_items,
+        prev_page: @prev_page,
+        next_page: @next_page,
+        is_first_page: @is_first_page,
+        is_last_page: @is_last_page
+      }
+    end
+  end
+end

data/lib/risa/query.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Risa
+  class Query
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :results, :each, :map, :select, :reject, :[], :size, :length,
+                   :empty?, :any?, :all?, :to_a, :inspect
+
+    def initialize(model_name, data, scopes, relations, conditions: [], order_field: nil, order_desc: false, limit_count: nil, offset_count: nil)
+      @model_name = model_name
+      @data = data
+      @scopes = scopes
+      @relations = relations
+      @conditions = conditions
+      @order_field = order_field
+      @order_desc = order_desc
+      @limit_count = limit_count
+      @offset_count = offset_count
+      @_results = nil
+      
+      @scopes.each do |scope_name, scope_lambda|
+        define_singleton_method(scope_name) do |*args|
+          begin
+            instance_exec(*args, &scope_lambda)
+          rescue => e
+            raise Risa::ScopeError, "Error in scope :#{scope_name} for model :#{@model_name}: #{e.message}\n  #{e.backtrace&.first}"
+          end
+        end
+      end
+    end
+    
+def where(condition_hash = nil, &block)
+  if block
+    sub_query = self.class.new(@model_name, @data, @scopes, @relations)
+    result_query = block.call(sub_query)
+    sub_conditions = result_query.instance_variable_get(:@conditions)
+    
+    Query.new(@model_name, @data, @scopes, @relations,
+             conditions: @conditions + [[:and_block, sub_conditions]],
+             order_field: @order_field,
+             order_desc: @order_desc,
+             limit_count: @limit_count,
+             offset_count: @offset_count)
+  elsif condition_hash
+    Query.new(@model_name, @data, @scopes, @relations,
+             conditions: @conditions + [condition_hash],
+             order_field: @order_field,
+             order_desc: @order_desc,
+             limit_count: @limit_count,
+             offset_count: @offset_count)
+  else
+    self
+  end
+end
+
+def or_where(condition_hash = nil, &block)
+  if block
+    sub_query = self.class.new(@model_name, @data, @scopes, @relations)
+    result_query = block.call(sub_query)
+    sub_conditions = result_query.instance_variable_get(:@conditions)
+    
+    Query.new(@model_name, @data, @scopes, @relations,
+             conditions: @conditions + [[:or_block, sub_conditions]],
+             order_field: @order_field,
+             order_desc: @order_desc,
+             limit_count: @limit_count,
+             offset_count: @offset_count)
+  elsif condition_hash
+    Query.new(@model_name, @data, @scopes, @relations,
+             conditions: @conditions + [[:or, condition_hash]],
+             order_field: @order_field,
+             order_desc: @order_desc,
+             limit_count: @limit_count,
+             offset_count: @offset_count)
+  else
+    self
+  end
+end
+    
+    def order(field, desc: false)
+      Query.new(@model_name, @data, @scopes, @relations,
+               conditions: @conditions,
+               order_field: field,
+               order_desc: desc,
+               limit_count: @limit_count,
+               offset_count: @offset_count)
+    end
+    
+    def limit(count)
+      Query.new(@model_name, @data, @scopes, @relations,
+               conditions: @conditions,
+               order_field: @order_field,
+               order_desc: @order_desc,
+               limit_count: count,
+               offset_count: @offset_count)
+    end
+    
+    def offset(count)
+      Query.new(@model_name, @data, @scopes, @relations,
+               conditions: @conditions,
+               order_field: @order_field,
+               order_desc: @order_desc,
+               limit_count: @limit_count,
+               offset_count: count)
+    end
+    
+    def all
+      results
+    end
+    
+    def first
+      raw_first = apply_filters.first
+      raw_first ? wrap_instance(raw_first) : nil
+    end
+
+    def last
+      raw_last = apply_filters.last
+      raw_last ? wrap_instance(raw_last) : nil
+    end
+
+    def find_by(conditions)
+      raw_found = where(conditions).apply_filters.first
+      raw_found ? wrap_instance(raw_found) : nil
+    end
+    
+    def count
+      results.length
+    end
+    
+    def each(&block)
+      all.each(&block)
+    end
+    
+    def paginate(per_page:)
+      raise ArgumentError, "per_page must be positive" if per_page <= 0
+      
+      total_items = raw_count
+      return [Page.new([], 1, 1, total_items)] if total_items == 0
+
+      total_pages = (total_items.to_f / per_page).ceil
+      (1..total_pages).map do |page_num|
+        offset_val = (page_num - 1) * per_page
+        items_per_page = if @limit_count && (@limit_count < per_page)
+                           remaining_items = [@limit_count - offset_val, 0].max
+                           [remaining_items, per_page].min
+                         else
+                           per_page
+                         end
+        items = self.offset(offset_val).limit(items_per_page).to_a
+        Page.new(items, page_num, total_pages, total_items)
+      end
+    end
+    
+    def raw_count
+      apply_filters.length
+    end
+    
+    def results
+      @_results ||= apply_filters.map { |hash| wrap_instance(hash) }
+    end
+    
+    def apply_filters
+      result = @data.dup
+      
+      # Handle no conditions
+      return apply_ordering_and_limits(result) if @conditions.empty?
+
+      # Process conditions with proper AND/OR logic
+      and_result = result.dup
+      or_results = []
+
+      @conditions.each do |condition|
+        if condition.is_a?(Array)
+          operator = condition[0]
+          
+          case operator
+          when :or
+            # OR with hash condition - evaluate against original dataset
+            condition_hash = condition[1]
+            matching = @data.select do |item|
+              condition_hash.all? { |field, value| evaluate_condition(item, field.to_sym, value) }
+            end
+            or_results.concat(matching)
+            
+          when :or_block
+            # OR with block condition - evaluate against original dataset
+            sub_conditions = condition[1]
+            temp_query = self.class.new(@model_name, @data, {}, @relations, conditions: sub_conditions)
+            matching = temp_query.apply_filters
+            or_results.concat(matching)
+            
+          when :and_block
+            # AND with block condition - apply to current AND result
+            sub_conditions = condition[1]
+            temp_query = self.class.new(@model_name, and_result, {}, @relations, conditions: sub_conditions)
+            and_result = temp_query.apply_filters
+          end
+        else
+          # Regular AND condition
+          and_result = and_result.select do |item|
+            condition.all? { |field, value| evaluate_condition(item, field.to_sym, value) }
+          end
+        end
+      end
+
+      # Combine results: AND results + OR results (remove duplicates)
+      final_result = and_result
+      unless or_results.empty?
+        final_result = (final_result + or_results).uniq
+      end
+      
+      apply_ordering_and_limits(final_result)
+    end
+
+    private
+
+    def apply_ordering_and_limits(data)
+      result = data
+      
+      if @order_field
+        # Separate nil values to always sort them to the end
+        nil_items = result.select { |item| item[@order_field.to_sym].nil? }
+        non_nil_items = result.reject { |item| item[@order_field.to_sym].nil? }
+        
+        # Sort non-nil items with proper type handling
+        sorted_non_nil = non_nil_items.sort_by do |item|
+          value = item[@order_field.to_sym]
+          case value
+          when Numeric then [0, value]
+          when String then [1, value]
+          when Date, Time then [2, value]
+          else [3, value.to_s]
+          end
+        end
+        
+        result = @order_desc ? sorted_non_nil.reverse + nil_items : sorted_non_nil + nil_items
+      end
+      
+      result = result[@offset_count..-1] || [] if @offset_count && @offset_count > 0
+      result = result[0, @limit_count] || [] if @limit_count
+      
+      result
+    end
+    
+    public :apply_filters
+    
+    private
+    
+    def evaluate_condition(item, field, value)
+      field_value = item[field]
+      
+      case value
+      when ::Hash
+        if value.key?(:contains)
+          field_value.to_s.include?(value[:contains].to_s)
+        elsif value.key?(:starts_with)
+          field_value.to_s.start_with?(value[:starts_with].to_s)
+        elsif value.key?(:ends_with)
+          field_value.to_s.end_with?(value[:ends_with].to_s)
+        elsif value.key?(:greater_than)
+          field_value && field_value > value[:greater_than]
+        elsif value.key?(:less_than)
+          field_value && field_value < value[:less_than]
+        elsif value.key?(:greater_than_or_equal)
+          field_value && field_value >= value[:greater_than_or_equal]
+        elsif value.key?(:less_than_or_equal)
+          field_value && field_value <= value[:less_than_or_equal]
+        elsif value.key?(:from) && value.key?(:to)
+          field_value && field_value >= value[:from] && field_value <= value[:to]
+        elsif value.key?(:from)
+          field_value && field_value >= value[:from]
+        elsif value.key?(:to)
+          field_value && field_value <= value[:to]
+        elsif value.key?(:in)
+          Array(value[:in]).include?(field_value)
+        elsif value.key?(:not_in)
+          !Array(value[:not_in]).include?(field_value)
+        elsif value.key?(:not)
+          field_value != value[:not]
+        elsif value.key?(:exists)
+          value[:exists] ? !field_value.nil? : field_value.nil?
+        elsif value.key?(:empty)
+          if value[:empty]
+            field_value.nil? || field_value == '' || (field_value.respond_to?(:empty?) && field_value.empty?)
+          else
+            !field_value.nil? && field_value != '' && !(field_value.respond_to?(:empty?) && field_value.empty?)
+          end
+        else
+          field_value == value
+        end
+      when Array
+        field_value.is_a?(Array) ? field_value == value : value.include?(field_value)
+      when Range
+        value.include?(field_value)
+      else
+        field_value == value
+      end
+    end
+    
+    def wrap_instance(hash)
+      InstanceWrapper.new(hash, @model_name)
+    end
+  end
+end

data/lib/risa/relations.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Risa
+  module Inflector
+    def self.pluralize(word)
+      str = word.to_s
+      str.end_with?('s') ? str : "#{str}s"
+    end
+
+    def self.singularize(word)
+      str = word.to_s
+      str.end_with?('s') ? str.chomp('s') : str
+    end
+  end
+
+  module Relations
+    module DSL
+      def relations
+        @relations ||= {}
+      end
+
+      def belongs_to(name, class_name: nil, foreign_key: nil, primary_key: :id)
+        relations[name.to_sym] = {
+          type: :belongs_to,
+          class_name: class_name || Risa::Inflector.pluralize(name).to_sym,
+          foreign_key: foreign_key || "#{name}_id".to_sym,
+          primary_key: primary_key
+        }
+      end
+
+      def has_many(name, class_name: nil, foreign_key: nil, through: nil, source: nil, owner_key: :id)
+        options = { type: :has_many, owner_key: owner_key }
+        if through
+          options[:through] = through.to_sym
+          options[:source] = source || Risa::Inflector.singularize(name).to_sym
+        else
+          options[:class_name] = class_name || name.to_sym
+          options[:foreign_key] = foreign_key || "#{Risa::Inflector.singularize(@model_name)}_id".to_sym
+        end
+        relations[name.to_sym] = options
+      end
+
+      def has_one(name, class_name: nil, foreign_key: nil, owner_key: :id)
+        relations[name.to_sym] = {
+          type: :has_one,
+          class_name: class_name || Risa::Inflector.pluralize(name).to_sym,
+          foreign_key: foreign_key || "#{Risa::Inflector.singularize(@model_name)}_id".to_sym,
+          owner_key: owner_key
+        }
+      end
+    end # End DSL
+
+    module Fetcher
+      private
+
+      def fetch_relation(name)
+        @_memoized[name] ||= begin
+          relation = @_relations[name]
+          raise "Undefined relation '#{name}' called on model '#{@_model_name}'" unless relation
+
+          case relation[:type]
+          when :belongs_to
+            fetch_belongs_to(relation)
+          when :has_one
+            fetch_has_one(relation)
+          when :has_many
+            relation[:through] ? fetch_has_many_through(relation) : fetch_has_many_direct(relation)
+          else
+            raise "Unknown relation type: #{relation[:type]}"
+          end
+        end
+      end
+
+      def fetch_belongs_to(relation)
+        foreign_key_value = @_hash[relation[:foreign_key]]
+        primary_key = relation[:primary_key]
+        foreign_key_value ? Risa.query(relation[:class_name]).find_by(primary_key => foreign_key_value) : nil
+      end
+
+      def fetch_has_one(relation)
+        owner_key_value = @_hash[relation[:owner_key]]
+        Risa.query(relation[:class_name]).find_by(relation[:foreign_key] => owner_key_value)
+      end
+
+      def fetch_has_many_direct(relation)
+        owner_key_value = @_hash[relation[:owner_key]]
+        Risa.query(relation[:class_name]).where(relation[:foreign_key] => owner_key_value)
+      end
+
+      def fetch_has_many_through(relation)
+        through_association_name = relation[:through]
+        source_association_name = relation[:source]
+
+        through_relation = @_relations[through_association_name]
+        unless through_relation && through_relation[:type] == :has_many && !through_relation[:through]
+          raise "Invalid 'through' association: #{through_association_name} on model '#{@_model_name}'. Must be a direct has_many."
+        end
+        intermediate_model_name = through_relation[:class_name]
+        intermediate_foreign_key = through_relation[:foreign_key]
+        intermediate_owner_key = through_relation[:owner_key]
+
+        intermediate_relations = Risa.relations_for(intermediate_model_name)
+        target_relation_on_intermediate = intermediate_relations[source_association_name]
+
+        unless target_relation_on_intermediate && target_relation_on_intermediate[:type] == :belongs_to
+           inferred_belongs_to = intermediate_relations.values.find do |rel|
+             rel[:type] == :belongs_to && Risa::Inflector.pluralize(rel[:class_name]).to_sym == source_association_name
+           end
+           target_relation_on_intermediate = inferred_belongs_to
+        end
+
+        unless target_relation_on_intermediate && target_relation_on_intermediate[:type] == :belongs_to
+           raise("Cannot find target 'belongs_to' association " \
+                 "(expected name like ':#{source_association_name}' or similar, found: #{intermediate_relations.keys.inspect}) " \
+                 "on intermediate model '#{intermediate_model_name}' for through relation " \
+                 "'#{through_association_name}' on model '#{@_model_name}'. Did you define the belongs_to on #{intermediate_model_name}?")
+        end
+
+        final_model_name = target_relation_on_intermediate[:class_name]
+        final_foreign_key_on_intermediate = target_relation_on_intermediate[:foreign_key]
+        final_primary_key = target_relation_on_intermediate[:primary_key]
+
+        intermediate_records = Risa.query(intermediate_model_name)
+                                  .where(intermediate_foreign_key => @_hash[intermediate_owner_key])
+                                  .to_a
+
+        target_ids = intermediate_records.map { |record| record[final_foreign_key_on_intermediate] }.compact.uniq
+
+        target_ids.empty? ? Risa.query(final_model_name).where(id: -1) : Risa.query(final_model_name).where(final_primary_key => { in: target_ids })
+      end
+    end # End Fetcher
+  end # End Relations
+end # End Risa

data/lib/risa/version.rb

@@ -0,0 +1,3 @@
+module Risa
+  VERSION = "1.0.0"
+end