acdc 0.5.1 → 0.6.0

data/lib/acdc.rb

@@ -11,55 +11,15 @@ class Boolean; end
 module AcDc
   
   DEFAULT_NAMESPACE = "acdc" unless defined?(AcDc::DEFAULT_NAMESPACE)
-  VERSION = [0,5,1] unless defined?(AcDc::VERSION)
+  VERSION = [0,6,0] unless defined?(AcDc::VERSION)
   
   if defined?(JAIL_BREAK)
     puts "AcDc is live -- Dirty Deeds!"
   end
-
-  def self.included(base)
-    base.instance_variable_set("@attributes",{})
-    base.instance_variable_set("@elements",{})
-    base.extend(ClassMethods)
-    base.extend(Parsing)
-  end
-  
-  module ClassMethods
-    def attributes
-      @attributes[to_s] || []
-    end
-
-    def elements
-      @elements[to_s] || []
-    end  
-    
-    def attribute(name, type, options={})
-      attribute = Attribute.new(name,type,options)
-      @attributes[to_s] ||= []
-      @attributes[to_s] << attribute
-      attr_accessor attribute.method_name.intern
-    end
-    
-    def element(name, type, options={})
-      element = Element.new(name,type,options)
-      @elements[to_s] ||= []
-      @elements[to_s] << element
-      attr_accessor element.method_name.intern
-    end
-    
-    def tag_name(name = nil)
-      @tag_name = name.to_s if name
-      @tag_name ||= to_s.split('::')[-1].downcase
-    end
-
-    def namespace(namespace = nil)
-      @namespace = namespace if namespace
-      @namespace
-    end
-    
-  end
   
 end
+
+require File.join(File.dirname(__FILE__), 'acdc/mapping')
 require File.join(File.dirname(__FILE__), 'acdc/build')
 require File.join(File.dirname(__FILE__), 'acdc/parse')
 require File.join(File.dirname(__FILE__), 'acdc/item')

data/lib/acdc/body.rb

@@ -1,62 +1,17 @@
 module AcDc
   class Body
     
+    include(Mapping)
+    include(Building)
+    
     def self.inherited(child)
-      attrs = @attributes.nil? ? [] : @attributes.dup
+      attrs = @attributes.nil? ? {} : @attributes.dup
       child.instance_variable_set("@attributes", attrs)
-      elems = @elements.nil? ? [] : @elements.dup
+      elems = @elements.nil? ? {} : @elements.dup
       child.instance_variable_set("@elements", elems)
       @inheritance_chain ||= []
       @inheritance_chain << child
     end    
-    
-    include(Build::ClassMethods)
-
-    extend(Parsing)
-    
-    module BodyClassMethods
       
-      def attributes
-        @attributes || []
-      end
-
-      def elements
-        @elements || []
-      end  
-
-      def attribute(name, type, options={})
-        attribute = Attribute.new(name,type,options)
-        @attributes ||= []
-        @attributes << attribute
-        unless @inheritance_chain.nil? 
-          @inheritance_chain.each { |child| child.attributes << attribute }
-        end
-        attr_accessor attribute.method_name.intern
-      end
-
-      def element(name, type, options={})
-        element = Element.new(name,type,options)
-        @elements ||= []
-        @elements << element
-        unless @inheritance_chain.nil? 
-          @inheritance_chain.each { |child| child.elements << element }
-        end
-        attr_accessor element.method_name.intern
-      end
-
-      def tag_name(name = nil)
-        @tag_name = name.to_s if name
-        @tag_name ||= to_s.split('::')[-1].downcase
-      end
-
-      def namespace(namespace = nil)
-        @namespace = namespace if namespace
-        @namespace
-      end
-
-    end
-   
-    extend(BodyClassMethods)
-    
   end
 end

data/lib/acdc/build.rb

@@ -1,35 +1,31 @@
 module AcDc
-  module Build
-    module ClassMethods
-      
-      # Converts object to XML
-      # Very poor support for multiple namespaces
-      def acdc(root = true)
-        xml = Builder::XmlMarkup.new
-        attrs = self.class.attributes.inject({}){ |acc,attr| 
-          acc.update(attr.method_name => send(attr.method_name.to_sym))
-        }
-        attrs.update(:xmlns => self.class.namespace) if self.class.namespace
-        xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8" if root
-        xml.tag!(self.class.tag_name,attrs){ |body|
-          self.class.elements.each do |elem|
-            value = send(elem.method_name.to_sym)
-            if value
-              if elem.primitive?
-                body.tag! elem.method_name, value 
-              else
-                body << value.acdc(false)
-              end
+  module Building
+    
+    # Converts object to XML
+    # Very poor support for multiple namespaces
+    def acdc(root = true)
+      xml = Builder::XmlMarkup.new
+      attrs = self.class.attributes.inject({}){ |acc,attr| 
+        acc.update(attr.method_name => send(attr.method_name.to_sym))
+      }
+      attrs.update(:xmlns => self.class.namespace) if self.class.namespace
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8" if root
+      xml.tag!(self.class.tag_name,attrs){ |body|
+        self.class.elements.each do |elem|
+          value = send(elem.method_name.to_sym)
+          if value
+            if elem.primitive?
+              body.tag! elem.method_name, value 
             else
-              body.tag! elem.method_name
+              body << value.acdc(false)
             end
+          else
+            body.tag! elem.method_name
           end
-        }
-        xml.target!
-      end
+        end
+      }
+      xml.target!
     end
-  end
-  
-  include Build::ClassMethods
-  
+
+  end  
 end

data/lib/acdc/mapping.rb

@@ -0,0 +1,62 @@
+module AcDc
+  module Mapping
+    
+    def self.included(base)
+      base.instance_variable_set("@attributes",{})
+      base.instance_variable_set("@elements",{})
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def attributes
+        @attributes[to_s] || []
+      end
+
+      def elements
+        @elements[to_s] || []
+      end  
+
+      def attribute(name, type, options={})
+        attribute = Attribute.new(name,type,options)
+        @attributes[to_s] ||= []
+        @attributes[to_s] << attribute
+        unless @inheritance_chain.nil? 
+          @inheritance_chain.each { |child| child.attribute(name,type,options) }
+        end
+        make_accessor(attribute)
+      end
+
+      def element(name, type, options={})
+        element = Element.new(name,type,options)
+        @elements[to_s] ||= []
+        @elements[to_s] << element
+        unless @inheritance_chain.nil?
+          @inheritance_chain.each { |child| child.element(name,type,options) }
+        end
+        make_accessor(element)
+      end
+
+      def tag_name(name = nil)
+        @tag_name = name.to_s if name
+        @tag_name ||= to_s.split('::')[-1].downcase
+      end
+
+      def namespace(namespace = nil)
+        @namespace = namespace if namespace
+        @namespace
+      end
+      
+      private
+        def make_accessor(item)
+          safe_name = item.name.tr('-','_')
+          if instance_methods.include?(safe_name)
+            name = "#{item.element? ? "element_" : "attribute_"}#{safe_name}"
+            item.name = name
+          end
+          attr_accessor item.method_name.intern
+        end
+
+    end
+    
+  end
+end

data/lib/acdc/parse.rb

@@ -50,10 +50,11 @@ module AcDc
       
       def constantize(type)
         if type.is_a?(String)
-          names = type.split('::')
           constant = Object
-          names.each do |name|
-            constant = const_defined?(name) ? const_get(name) : const_missing(name)
+          all_class_names.each do |name|
+            if name.downcase == type.downcase
+              constant = const_get(name)
+            end
           end
           constant
         else
@@ -62,4 +63,28 @@ module AcDc
       end
     
   end
+end
+
+class Module
+  
+  def hierarchy
+    name.split('::').inject([Object]) {|hierarchy,name|
+      hierarchy << hierarchy.last.const_get(name)
+    }
+  end
+  
+  def all_class_names
+    class_names = []
+    constants.each do |const|
+      constant = const_get(const)
+      case constant
+      when Class
+        class_names << constant.to_s.split('::',2)[1]
+      when Module
+        class_names += constant.all_class_names
+      end
+    end
+    class_names.uniq
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: acdc
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - Clint Hill
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-19 00:00:00 -07:00
+date: 2009-09-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.1.2
     version: 
-description: "    This is a little xml-to-object-to-xml library that gets Dirty Deeds Done Dirt Cheap. \n"
+description: This is a little xml-to-object-to-xml library that gets Dirty Deeds Done Dirt Cheap.
 email: clint.hill@h3osoftware.com
 executables: []
 
@@ -41,21 +41,21 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- LICENSE
-- README
-- Rakefile
-- lib/acdc.rb
 - lib/acdc/attribute.rb
 - lib/acdc/body.rb
+- lib/acdc/build.rb
 - lib/acdc/element.rb
 - lib/acdc/item.rb
+- lib/acdc/mapping.rb
 - lib/acdc/parse.rb
-- lib/acdc/build.rb
+- lib/acdc.rb
+- README
+- LICENSE
 has_rdoc: true
-homepage: http://h3osoftware.com/acdc
+homepage: http://github.com/clinth3o/acdc
 licenses: []
 
-post_install_message: 
+post_install_message: For those about to rock ... we salute you!
 rdoc_options: []
 
 require_paths: 
@@ -74,10 +74,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: acdc
+rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: AC/DC by h3o(software)
+summary: acdc 0.6.0
 test_files: []
 

data/Rakefile

@@ -1,201 +0,0 @@
-require 'rake'
-require 'rake/clean'                       
-require 'rake/gempackagetask'
-require 'spec/rake/spectask'
-require 'fileutils'
-require 'yard'
-include FileUtils
-require File.join(File.dirname(__FILE__),"lib","acdc")
-include AcDc
-
-spec = Gem::Specification.new do |s|
-  s.name = "acdc"
-  s.version = AcDc::VERSION.join(".")
-  s.platform = Gem::Platform::RUBY
-  s.author = "Clint Hill"
-  s.email = "clint.hill@h3osoftware.com"
-  s.homepage = "http://h3osoftware.com/acdc"
-  s.summary = "AC/DC by h3o(software)"
-  s.description = <<-EOF
-    This is a little xml-to-object-to-xml library that gets Dirty Deeds Done Dirt Cheap. 
-  EOF
-  s.rubyforge_project = "acdc"
-  s.require_path = "lib"
-  s.files = [
-     "LICENSE",
-     "README",
-     "Rakefile",
-     "lib/acdc.rb",
-     "lib/acdc/attribute.rb",
-     "lib/acdc/body.rb",
-     "lib/acdc/element.rb",
-     "lib/acdc/item.rb",
-     "lib/acdc/parse.rb",
-     "lib/acdc/build.rb"
-  ]
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<libxml-ruby>, [">= 1.1.3"])
-      s.add_runtime_dependency(%q<builder>, [">= 2.1.2"])
-    else
-      s.add_dependency(%q<libxml-ruby>, [">= 1.1.3"])
-      s.add_dependency(%q<builder>, [">= 2.1.2"])
-    end
-  else
-    s.add_dependency(%q<libxml-ruby>, [">= 1.1.3"])
-    s.add_dependency(%q<builder>, [">= 2.1.2"])
-  end
-end
-
-Rake::GemPackageTask.new(spec) do |package|
- package.gem_spec = spec
-end
-
-
-
-##############################################################################
-# rSpec
-##############################################################################
-desc 'Run all specs and rcov'
-task :spec => ["spec:default"]
-namespace :spec do
-  Spec::Rake::SpecTask.new('default') do |t|
-      t.spec_opts = ["--format", "specdoc", "--colour"]
-      t.spec_files = Dir['spec/**/*_spec.rb'].sort
-      t.libs = ['lib','lib/acdc'] 
-  end
-end
-
-##############################################################################
-# Documentation
-##############################################################################
-task :doc => ["doc:yardoc"]
-namespace :doc do
-  YARD::Rake::YardocTask.new do |t|
-    t.options = ['-odoc/yardoc', '-rREADME', '-mtextile'] # optional
-  end
-end
-
-#############################################################################
-# Stats
-#############################################################################
-STATS_DIRECTORIES = [
-  %w(AcDc       lib/acdc),
-  %w(Specs      spec)
-].collect { |name, dir| [ name, "#{Dir.pwd}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
-
-desc "Report code statistics (KLOCs, etc) from the application"
-task :stats do
-  CodeStatistics.new(*STATS_DIRECTORIES).to_s
-end
-
-class CodeStatistics #:nodoc:
-
-  TEST_TYPES = %w(Specs)
-
-  def initialize(*pairs)
-    @pairs      = pairs
-    @statistics = calculate_statistics
-    @total      = calculate_total if pairs.length > 1
-  end
-
-  def to_s
-    print_header
-    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
-    print_splitter
-  
-    if @total
-      print_line("Total", @total)
-      print_splitter
-    end
-
-    print_code_test_stats
-  end
-
-  private
-    def calculate_statistics
-      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
-    end
-
-    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
-      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
-
-      Dir.foreach(directory) do |file_name| 
-        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
-          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
-          stats.each { |k, v| stats[k] += newstats[k] }
-        end
-
-        next unless file_name =~ pattern
-
-        f = File.open(directory + "/" + file_name)
-
-        while line = f.gets
-          stats["lines"]     += 1
-          stats["classes"]   += 1 if line =~ /class [A-Z]/
-          stats["methods"]   += 1 if line =~ /def [a-z]/
-          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
-        end
-      end
-
-      stats
-    end
-
-    def calculate_total
-      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
-      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
-      total
-    end
-
-    def calculate_code
-      code_loc = 0
-      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
-      code_loc
-    end
-
-    def calculate_tests
-      test_loc = 0
-      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
-      test_loc
-    end
-
-    def print_header
-      print_splitter
-      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
-      print_splitter
-    end
-
-    def print_splitter
-      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
-    end
-
-    def print_line(name, statistics)
-      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
-      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
-
-      start = if TEST_TYPES.include? name
-        "| #{name.ljust(20)} "
-      else
-        "| #{name.ljust(20)} " 
-      end
-
-      puts start + 
-           "| #{statistics["lines"].to_s.rjust(5)} " +
-           "| #{statistics["codelines"].to_s.rjust(5)} " +
-           "| #{statistics["classes"].to_s.rjust(7)} " +
-           "| #{statistics["methods"].to_s.rjust(7)} " +
-           "| #{m_over_c.to_s.rjust(3)} " +
-           "| #{loc_over_m.to_s.rjust(5)} |"
-    end
-
-    def print_code_test_stats
-      code  = calculate_code
-      tests = calculate_tests
-
-      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
-      puts ""
-    end
-end