magnetic 0.0.1

data/gemspec.rb

@@ -0,0 +1,31 @@
+
+lib, version = File::basename(File::dirname(File::expand_path(__FILE__))).split %r/-/, 2
+
+require 'rubygems'
+
+Gem::Specification::new do |spec|
+  $VERBOSE = nil
+  spec.name = lib 
+  spec.version = version 
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = lib 
+
+  spec.files = Dir::glob "**/**"
+  spec.executables = Dir::glob("bin/*").map{|exe| File::basename exe}
+  
+  spec.require_path = "lib" 
+  spec.autorequire = lib
+
+  spec.has_rdoc = File::exist? "doc" 
+  spec.test_suite_file = "test/#{ lib }.rb" if File::directory? "test"
+  spec.add_dependency 'pervasives', '~> 1.0'
+  spec.add_dependency 'arrayfields', '~> 3.7'
+  spec.add_dependency 'attributes', '~> 3.3'
+  spec.add_dependency 'prototype', '~> 2.0'
+
+  spec.extensions << "extconf.rb" if File::exists? "extconf.rb"
+
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://codeforpeople.com/lib/ruby/#{ lib }/"
+end

data/lib/magnetic.rb

@@ -0,0 +1,21 @@
+#
+# built-in
+#
+  require 'pathname'
+  require 'fileutils'
+#
+# gems
+#
+  require 'rubygems'
+  require 'pervasives'
+  require 'arrayfields'
+  require 'attributes'
+  require 'prototype'
+#
+# magnetic
+#
+  require 'magnetic/binding_of_caller'
+  require 'magnetic/rubyext'
+  require 'magnetic/field'
+  require 'magnetic/interface'
+  require 'magnetic/rails'

data/lib/magnetic/binding_of_caller.rb

@@ -0,0 +1,84 @@
+begin
+  require 'simplecc'
+rescue LoadError
+  class Continuation # :nodoc: # for RDoc
+  end
+  def Continuation.create(*args, &block) # :nodoc:
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
+end
+
+class Binding; end # for RDoc
+# This method returns the binding of the method that called your
+# method. It will raise an Exception when you're not inside a method.
+#
+# It's used like this:
+#   def inc_counter(amount = 1)
+#     Binding.of_caller do |binding|
+#       # Create a lambda that will increase the variable 'counter'
+#       # in the caller of this method when called.
+#       inc = eval("lambda { |arg| counter += arg }", binding)
+#       # We can refer to amount from inside this block safely.
+#       inc.call(amount)
+#     end
+#     # No other statements can go here. Put them inside the block.
+#   end
+#   counter = 0
+#   2.times { inc_counter }
+#   counter # => 2
+#
+# Binding.of_caller must be the last statement in the method.
+# This means that you will have to put everything you want to
+# do after the call to Binding.of_caller into the block of it.
+# This should be no problem however, because Ruby has closures.
+# If you don't do this an Exception will be raised. Because of
+# the way that Binding.of_caller is implemented it has to be
+# done this way.
+def Binding.of_caller(&block)
+  old_critical = Thread.critical
+  Thread.critical = true
+  count = 0
+  cc, result, error, extra_data = Continuation.create(nil, nil)
+  error.call if error
+
+  tracer = lambda do |*args|
+    type, context, extra_data = args[0], args[4], args
+    if type == "return"
+      count += 1
+      # First this method and then calling one will return --
+      # the trace event of the second event gets the context
+      # of the method which called the method that called this
+      # method.
+      if count == 2
+        # It would be nice if we could restore the trace_func
+        # that was set before we swapped in our own one, but
+        # this is impossible without overloading set_trace_func
+        # in current Ruby.
+        set_trace_func(nil)
+        cc.call(eval("binding", context), nil, extra_data)
+      end
+    elsif type == "line" then
+      nil
+    elsif type == "c-return" and extra_data[3] == :set_trace_func then
+      nil
+    else
+      set_trace_func(nil)
+      error_msg = "Binding.of_caller used in non-method context or " +
+        "trailing statements of method using it aren't in the block."
+      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
+    end
+  end
+
+  unless result
+    set_trace_func(tracer)
+    return nil
+  else
+    Thread.critical = old_critical
+    case block.arity
+      when 1 then yield(result)
+      else yield(result, extra_data)        
+    end
+  end
+end

data/lib/magnetic/field.rb

@@ -0,0 +1,227 @@
+module Magnetic
+  module Field
+    Base = Object.prototype do
+      name nil
+      owner nil
+      #controller nil
+      model nil
+      #interface nil
+      #records nil
+      value nil
+      #path nil
+      type :html 
+
+      def __
+        @__ ||= Pervasives::Proxy.new(self)
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      attribute('template_root'){ File.join RAILS_ROOT, 'app', 'views', 'magnetic' }
+      attribute('template_dir'){ File.join template_root, File.join(*owner.name.gsub(%r/^:+/,'').split(%r/::/)).downcase }
+      attribute('template_base'){ name }
+      #attribute('template_ext'){ type.to_s  }
+      attribute('template_prefix'){ File.join(template_dir, template_base) }
+      attribute('template_inline'){ send "template_inline_#{ type }" }
+      attribute('template_text'){ nil }
+      attribute('template_map'){ { 'html' => 'rhtml', 'xml' => 'rxml' } }
+
+#
+# TODO - this needs to be thought out further
+#
+      def render *argv 
+        raise 'recursive render!' if defined?(@inside_render) and @inside_render
+        @inside_render = true
+        begin
+          field = self
+
+          type = argv.delete_first{|arg| String === arg or Symbol === arg } || self.type
+          type = type.to_s
+
+          options = argv.delete_first{|arg| Hash === arg} || {}
+          options.to_options!
+
+          msg = options.delete(:render) || :render_to_string
+
+          text = options[:text] || template_text rescue nil
+          inline = options[:inline] || template_inline rescue nil
+
+          unless text or inline
+            file = options[:file] 
+            unless file
+              ext = (template_map[type] || type).gsub %r/^\.?/, '.'
+              options[:file] = template_prefix + ext
+            end
+          end
+
+          controller.clone.instance_eval do
+            @field = field 
+            (options[:locals] ||= {}).update :field => @field 
+            send msg, options
+          end
+        ensure
+          @inside_render = false
+        end
+      end
+
+      def configure options = {}, &block
+        options.to_options!
+        prototyping do
+          options.each do |k,v|
+            begin
+              __send__ "#{ k }=", v
+            rescue
+              __attribute__ k => v
+            end
+          end
+        end
+        prototyping &block
+        self
+      end
+      alias_method 'configured', 'configure'
+
+      def to_proc
+        @to_proc ||= lambda do |options|
+          options.to_options!
+          field = self
+          value = options[:value]
+          unless value.nil?
+            sc =
+              class << value
+                self
+              end
+            sc.module_eval do
+              define_method :field do
+                field.configure options
+                field
+              end
+            end
+          end
+        end
+      end
+
+
+      def to_proc
+        @to_proc ||= lambda do |options|
+          field = self
+          field_options = options.to_options
+          value = options[:value]
+          raise ArgumentError, "no value in <#{ options.inspect }>" unless value
+          value.extend ConfiguredFieldMethod
+          value.field = field 
+          value.field_options = field_options
+        end
+      end
+
+      module ConfiguredFieldMethod
+        attr_writer 'field'
+        attr_writer 'field_options'
+
+        def field
+          @field_options.each do |k, v|
+            unless @field.respond_to? k
+              sc =
+                class << @field
+                  self
+                end
+              sc.module_eval{ attribute k }
+            end
+            @field.send "#{ k }=", v
+          end
+          @field
+        end
+      end
+
+      def === other
+        Base.class === other
+      end
+    end
+
+### TODO try not to use array fields here
+    class Set < ::Array
+      include Fieldable
+      class << self
+        def [] *a, &b
+          a = super
+        ensure
+          a.fields = []
+        end
+      end
+      def initialize *a, &b
+        super
+      ensure
+        self.fields = []
+      end
+    end
+
+    module DSL
+      def fieldset
+        @fieldset ||= Field::Set[]
+      end
+      def field *argv, &block
+        name = argv.delete_first{|arg| String === arg or Symbol === arg }
+        base = argv.delete_first{|arg| Field::Base.class === arg}
+        configuring = argv.delete_first{|arg| ['configure', :configure, 'configuring', :configuring].include? arg}
+        options = argv.delete_first{|arg| Hash === arg}
+
+        name ||= base.name
+        raise ArgumentError, 'nameless field!' unless name
+        name = name.to_s
+
+        if options.nil? and base.nil? and block.nil?
+          field = field_for name
+          field.clone unless field.nil? 
+        else
+          options ||= {}
+          options.to_options!
+          field =
+            if configuring
+              field_for name
+            else
+              base ||= Field::Base
+              field = base.clone
+              field.name = name
+              field.owner = self 
+              field
+            end
+
+          field.configure options, &block
+
+#p [ (field.owner.name rescue field.owner.class.name), field.name, (configuring ? :configuring : false), caller.first ]
+
+          unless configuring
+            raise ArgumentError, "duplicate field '#{ name }' in #{ fieldset[name].inspect }" if fieldset.has_key?(field.name)
+            fieldset[field.name] = field
+          end
+
+          field
+        end
+      end
+      def field_for name
+        fieldset[name.to_s]
+      end
+      def self.included other
+        super
+      ensure
+        other.extend self
+      end
+    end
+  end
+
+  def self.field *argv, &block
+    name = argv.delete_first{|arg| String === arg or Symbol === arg }
+    base = argv.delete_first{|arg| Field::Base.class === arg}
+    configure = argv.delete_first{|arg| ['configure', :configure].include? arg}
+    options = argv.delete_first{|arg| Hash === arg}
+    options ||= {}
+    options.to_options!
+    base ||= Field::Base
+    field = base.clone
+    field.name = name
+    field.owner = self 
+    field.configure options, &block
+    field
+  end
+end

data/lib/magnetic/interface.rb

@@ -0,0 +1,99 @@
+module Magnetic
+  class Path < ::String; end
+  def self.path(*a, &b) a.size == 0 ? Path : Path.new(*a, &b) end
+
+  class Interface 
+    include Magnetic::Field::DSL
+
+    attribute 'records'
+    attribute 'mapping'
+
+    def initialize options = {}, &block
+      options.to_options!
+      records = options[:records]
+      controller = options[:controller]
+      @records = (( Array === records and ActiveRecord::Base === records[0] )) ? records : [records]
+      @records = [] if records.nil?
+      @controller = controller
+      @mapping = []
+      instance_eval &block if block
+      post_initialize
+    end
+
+    def map mapping
+      mapping.each do |key, value|
+        key = key.to_s
+        raise ArgumentError, 'empty key!' if key.empty?
+        raise ArgumentError, 'no value!' if value.nil?
+        @mapping << [key, value]
+        if Magnetic::Field::Base === value
+          field(value) unless field(value.name)
+        end
+      end
+    end
+
+    def post_initialize
+      map!
+    end
+
+    def map!
+      @records.each{|record| map_record :record => record, :mapping => @mapping} unless @mapping.empty?
+    end
+
+    def map_record options = {} 
+      options.to_options!
+
+      record = options.delete :record
+      mapping = options.delete :mapping
+      route = options.delete :route
+
+      table_name = record.class.table_name
+      id = record.id
+
+      (( route ||= [] )) << "#{ table_name }[#{ id }]"
+
+      mapping.each do |path, block|
+        head, *tail = path.split '.'
+        m, head, array, *ignored = %r/^(.*?)(\[\*?\])?$/o.match(head).to_a
+        
+        if array 
+          subrecords = record.send head 
+          subrecords = [subrecords] unless subrecords.class == Array
+          subpath = tail.join '.'
+          subblock = block
+          submapping = [[ subpath, subblock ]]
+          subrecords.each do |subrecord|
+            subroute = route.clone 
+            map_record :record => subrecord, :mapping => submapping, :route => subroute
+          end
+        else
+          value = record.send head
+          path = Magnetic.path(( [route, head].join('.') ))
+          block.to_proc.call :path => path,
+                             :value => value,
+                             :model => record.class,
+                             :table_name => table_name,
+                             :column_name => head,
+                             :record => record,
+                             :interface => self,
+                             :controller => @controller
+        end
+      end
+    end
+
+    module DSL
+      def interface *a, &b
+        if a.empty? and b.nil?
+          @interface
+        else
+          @interface = Interface.new :records => a.shift, :controller => self, &b
+        end
+      end
+      def self.included other
+        super
+      ensure
+        other.extend self
+      end
+    end
+  end
+end

data/lib/magnetic/rails.rb

@@ -0,0 +1,32 @@
+if defined? Rails or defined? RAILS
+  class ActiveRecord::Base
+    include Magnetic::Field::DSL
+
+    def self.field_for name
+      name = name.to_s
+      fieldset[name] or generate_default_field_for(name)
+    end
+
+    def self.generate_default_field_for name 
+      cname = name.to_s
+      m = self
+      raise ArgumentError, "no such column <#{ cname }>" unless columns_hash[cname]
+      field cname do
+        model m
+      end
+    end
+  end
+
+  if defined? ActionController
+    class ActionController::Base 
+      include Magnetic::Interface::DSL
+    end
+  end
+
+  unless defined? ApplicationController
+    class ApplicationController < ActionController::Base; end
+  end
+  class ApplicationController
+    include Magnetic::Interface::DSL
+  end
+end

data/lib/magnetic/rubyext.rb

@@ -0,0 +1,30 @@
+class Object
+  def higherself 
+    Binding.of_caller{|binding| eval 'self', binding}
+  end
+end
+class Hash
+unless instance_methods.include? 'to_options'
+  def to_options
+    keys.inject({}){|h,k| h.update k.to_s.to_sym => self[k]}
+  end
+end
+unless instance_methods.include? 'to_options!'
+  def to_options!
+    replace to_options
+  end
+end
+end
+class Array
+  def delete_first *argv, &block
+    match = block ? block : lambda{|arg| argv.first == arg}
+    at = nil
+    each_with_index do |element, index|
+      if match[element]
+        at = index
+        break
+      end
+    end
+    at ? delete_at(at) : nil
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: magnetic
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-06-04 00:00:00 -06:00
+summary: magnetic
+require_paths: 
+- lib
+email: ara.t.howard@gmail.com
+homepage: http://codeforpeople.com/lib/ruby/magnetic/
+rubyforge_project: 
+description: 
+autorequire: magnetic
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ara T. Howard
+files: 
+- gemspec.rb
+- lib
+- lib/magnetic
+- lib/magnetic/binding_of_caller.rb
+- lib/magnetic/field.rb
+- lib/magnetic/interface.rb
+- lib/magnetic/rails.rb
+- lib/magnetic/rubyext.rb
+- lib/magnetic.rb
+- magnetic-0.0.1.gem
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pervasives
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: arrayfields
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.7"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: attributes
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.3"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: prototype
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: