honkster-active_hash 0.7.3

data/geminstaller.yml

@@ -0,0 +1,13 @@
+defaults:
+  install_options: --source=http://gemcutter.org --source=http://gems.rubyforge.org --include-dependencies --no-ri --no-rdoc
+gems:
+- name: acts_as_fu
+  version: 0.0.5
+- name: activesupport
+  version: >= 2.2.2
+- name: rspec
+  version: >= 1.2.8
+- name: fixjour
+  version: 0.2.0
+- name: jeweler
+  version: 1.2.1

data/lib/active_file/base.rb

@@ -0,0 +1,50 @@
+module ActiveFile
+
+  class Base < ActiveHash::Base
+    class_inheritable_accessor :filename, :root_path, :data_loaded
+
+    class << self
+
+      def all
+        reload unless data_loaded
+        super
+      end
+
+      def delete_all
+        self.data_loaded = true
+        super
+      end
+
+      def reload(foo = true)
+        self.data_loaded = true
+        self.data = load_file
+      end
+
+      def set_filename(name)
+        write_inheritable_attribute :filename, name
+      end
+
+      def set_root_path(path)
+        write_inheritable_attribute :root_path, path
+      end
+
+      def load_file
+        raise "Override Me"
+      end
+
+      def full_path
+        root_path = read_inheritable_attribute(:root_path)  || Dir.pwd
+        filename  = read_inheritable_attribute(:filename)   || name.tableize
+        File.join(root_path, "#{filename}.#{extension}")
+      end
+
+      def extension
+        raise "Override Me"
+      end
+
+      protected :extension
+
+    end
+  end
+
+end

data/lib/active_hash.rb

@@ -0,0 +1,5 @@
+require 'activesupport'
+require 'active_hash/base'
+require 'active_file/base'
+require 'active_yaml/base'
+require 'associations/associations'

data/lib/active_hash/base.rb

@@ -0,0 +1,265 @@
+module ActiveHash
+  class Base
+    class_inheritable_accessor :data
+    class << self
+      attr_reader :field_names
+
+      def data=(array_of_hashes)
+        @records = nil
+        write_inheritable_attribute(:data, array_of_hashes)
+        if array_of_hashes
+          auto_assign_fields( array_of_hashes )
+          array_of_hashes.each do |hash|
+            insert new(hash)
+          end
+        end
+      end
+
+      def insert(record)
+        @records ||= []
+        record.attributes[:id] ||= next_id
+        @records << record
+      end
+
+      def next_id
+        max_record = all.max {|a, b| a.id <=> b.id }
+        if max_record.nil?
+          1
+        elsif max_record.id.is_a?(Numeric)
+          max_record.id.succ
+        end
+      end
+
+      def create(attributes = {})
+        record = new(attributes)
+        record.save
+        record
+      end
+
+      def create!(attributes = {})
+        record = new(attributes)
+        record.save!
+        record
+      end
+
+      def all
+        @records || []
+      end
+
+      def count
+        all.length
+      end
+
+      def transaction
+        yield
+      rescue ActiveRecord::Rollback
+
+      end
+
+      def delete_all
+        @records = []
+      end
+
+      def find(id, *args)
+        case id
+          when :all
+            all
+          when Array
+            all.select {|record| id.map(&:to_i).include?(record.id) }
+          else
+            find_by_id(id)
+        end
+      end
+
+      def find_by_id(id)
+        all.detect {|record| record.id == id.to_i}
+      end
+
+      delegate :first, :last, :to => :all
+
+      def fields(*args)
+        options = args.extract_options!
+        args.each do |field|
+          field(field, options)
+        end
+      end
+
+      def field(field_name, options = {})
+        @field_names ||= []
+        @field_names << field_name
+
+        define_getter_method(field_name, options[:default])
+        define_setter_method(field_name)
+        define_interrogator_method(field_name)
+        define_custom_find_method(field_name)
+        define_custom_find_all_method(field_name)
+      end
+
+      def respond_to?(method_name, include_private=false)
+        super ||
+          begin
+            config = configuration_for_custom_finder(method_name)
+            config && config[:fields].all? do |field|
+              field_names.include?(field.to_sym) || field.to_sym == :id
+            end
+          end
+      end
+
+      def method_missing(method_name, *args)
+        return super unless respond_to? method_name
+
+        config = configuration_for_custom_finder(method_name)
+        attribute_pairs = config[:fields].zip(args)
+        matches = all.select { |base| attribute_pairs.all? { |field, value| base.send(field).to_s == value.to_s } }
+        config[:all?] ? matches : matches.first
+      end
+
+      def configuration_for_custom_finder(finder_name)
+        if finder_name.to_s.match(/^find_(all_)?by_(.*)/)
+          {
+            :all?   => !!$1,
+            :fields => $2.split('_and_')
+          }
+        end
+      end
+
+      private :configuration_for_custom_finder
+
+      def define_getter_method(field, default_value)
+        unless instance_methods.include?(field.to_s)
+          define_method(field) do
+            attributes[field].nil? ? default_value : attributes[field]
+          end
+        end
+      end
+
+      private :define_getter_method
+
+      def define_setter_method(field)
+        method_name = "#{field}="
+        unless instance_methods.include?(method_name)
+          define_method(method_name) do |new_val|
+            attributes[field] = new_val
+          end
+        end
+      end
+
+      private :define_setter_method
+
+      def define_interrogator_method(field)
+        method_name = "#{field}?"
+        unless instance_methods.include?(method_name)
+          define_method(method_name) do
+            send(field).present?
+          end
+        end
+      end
+
+      private :define_interrogator_method
+
+      def define_custom_find_method(field_name)
+        method_name = "find_by_#{field_name}"
+        unless singleton_methods.include?(method_name)
+          metaclass.instance_eval do
+            define_method(method_name) do |name|
+              all.detect {|record| record.send(field_name) == name }
+            end
+          end
+        end
+      end
+
+      private :define_custom_find_method
+
+      def define_custom_find_all_method(field_name)
+        method_name = "find_all_by_#{field_name}"
+        unless singleton_methods.include?(method_name)
+          metaclass.instance_eval do
+            unless singleton_methods.include?(method_name)
+              define_method(method_name) do |name|
+                all.select {|record| record.send(field_name) == name }
+              end
+            end
+          end
+        end
+      end
+
+      private :define_custom_find_all_method
+
+      def auto_assign_fields(array_of_hashes)
+        (array_of_hashes || []).inject([]) do |array, row|
+          row.symbolize_keys!
+          row.keys.each do |key|
+            unless key.to_s == "id"
+              array << key
+            end
+          end
+          array
+        end.uniq.each do |key|
+          field key
+        end
+      end
+
+      private :auto_assign_fields
+
+      # Needed for ActiveRecord polymorphic associations
+      def base_class
+        ActiveHash::Base
+      end
+
+    end
+
+    attr_reader :attributes
+
+    def initialize(options = {})
+      options.symbolize_keys!
+      @attributes = options
+      options.each do |key, value|
+        send "#{key}=", value
+      end
+    end
+
+    def id
+      attributes[:id] ? attributes[:id] : nil
+    end
+
+    def id=(id)
+      attributes[:id] = id
+    end
+
+    alias quoted_id id
+
+    def new_record?
+      ! self.class.all.include?(self)
+    end
+
+    def readonly?
+      true
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    def eql?(other)
+      other.instance_of?(self.class) and not id.nil? and (id == other.id)
+    end
+
+    alias == eql?
+
+    def hash
+      id.hash
+    end
+
+    def save
+      self.class.insert(self)
+      true
+    end
+
+    alias save! save
+
+    def valid?
+      true
+    end
+
+  end
+end

data/lib/active_yaml/base.rb

@@ -0,0 +1,24 @@
+module ActiveYaml
+
+  class Base < ActiveFile::Base
+    class << self
+      def load_file
+        if (data = raw_data).is_a?(Array)
+          data
+        else
+          data.values
+        end
+      end
+
+      def raw_data
+        YAML.load_file(full_path)
+      end
+
+      def extension
+        "yml"
+      end
+
+    end
+  end
+
+end

data/lib/associations/associations.rb

@@ -0,0 +1,40 @@
+module ActiveHash
+  module Associations
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def has_many(association_id, options = {})
+
+        define_method(association_id) do
+          options = {
+            :class_name => association_id.to_s.classify,
+            :foreign_key => self.class.to_s.foreign_key
+          }.merge(options)
+
+          options[:class_name].constantize.send("find_all_by_#{options[:foreign_key]}", id)
+        end
+
+      end
+
+      def belongs_to(association_id, options = {})
+
+        options = {
+          :class_name => association_id.to_s.classify,
+          :foreign_key => association_id.to_s.foreign_key
+        }.merge(options)
+
+        define_method(association_id) do
+          options[:class_name].constantize.find(send(options[:foreign_key]))
+        end
+
+        define_method("#{association_id}=") do |new_value|
+          attributes[ options[:foreign_key].to_sym ] = new_value.id
+        end
+
+      end
+    end
+  end
+end

data/spec/active_file/base_spec.rb

@@ -0,0 +1,83 @@
+require 'spec/spec_helper'
+
+describe ActiveFile::Base do
+  before do
+    class Country < ActiveFile::Base
+    end
+  end
+
+  after do
+    Object.send :remove_const, :Country
+  end
+
+  describe ".filename=" do
+    before do
+      Country.filename = "foo-izzle"
+
+      class Bar < ActiveFile::Base
+        self.filename = "bar-izzle"
+      end
+    end
+
+    it "sets the filename on a per-subclass basis" do
+      Country.filename.should == "foo-izzle"
+      Bar.filename.should == "bar-izzle"
+    end
+  end
+
+  describe ".set_filename" do
+    before do
+      Country.set_filename "foo-izzle"
+
+      class Bar < ActiveFile::Base
+        set_filename "bar-izzle"
+      end
+    end
+
+    it "sets the filename on a per-subclass basis" do
+      Country.filename.should == "foo-izzle"
+      Bar.filename.should == "bar-izzle"
+    end
+  end
+
+  describe ".root_path=" do
+    before do
+      Country.root_path = "foo-izzle"
+
+      class Bar < ActiveFile::Base
+        self.root_path = "bar-izzle"
+      end
+    end
+
+    it "sets the root_path on a per-subclass basis" do
+      Country.root_path.should == "foo-izzle"
+      Bar.root_path.should == "bar-izzle"
+    end
+  end
+
+  describe ".set_root_path" do
+    before do
+      Country.set_root_path "foo-izzle"
+
+      class Bar < ActiveFile::Base
+        set_root_path "bar-izzle"
+      end
+    end
+
+    it "sets the root_path on a per-subclass basis" do
+      Country.root_path.should == "foo-izzle"
+      Bar.root_path.should == "bar-izzle"
+    end
+  end
+
+  describe ".full_path" do
+    it "defaults to the directory of the calling file" do
+      class Country
+        def self.extension() "foo" end
+      end
+
+      Country.full_path.should == "#{Dir.pwd}/countries.foo"
+    end
+  end
+
+end