confuddle 0.0.1

data/bin/un.cmd

@@ -0,0 +1 @@
+"ruby.exe" "%~dpn0" %*

data/confuddle.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + "/lib/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{confuddle}
+  s.version = Un::VERSION
+  s.authors = ["Makarchev Konstantin"]
+  s.description = %q{Utility for work with unfuddle.com account from console}
+  s.summary = %q{Utility for work with unfuddle.com account from console}
+
+  s.email = %q{kostya27@gmail.com}
+  s.homepage = %q{http://github.com/kostya/confuddle}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.add_dependency 'activesupport', ">=2.3.2"
+  s.add_dependency 'thor', ">=0.14.3"
+  s.add_dependency 'hpricot'
+  
+end

data/lib/graft/README.rdoc

@@ -0,0 +1,138 @@
+= Graft
+
+== Description
+
+Graft provides an easy way to map XML and JSON data onto your Ruby classes.
+
+== Installation
+
+Stable:
+
+    $ sudo gem install graft
+    
+Bleeding edge:
+
+    $ git clone git://github.com/reagent/graft.git
+    $ cd graft && rake gem
+    $ sudo gem install pkg/graft-<version>.gem
+
+== Usage
+
+When interacting with APIs, it's quite often the case that the data returned as
+part of the response is represented either as XML or JSON.  The Graft library makes
+turning that data into Ruby objects pretty simple.  This code was an extraction from
+my work on both the Fleakr[http://reagent.github.com/fleakr] and 
+Etsy[http://github.com/reagent/etsy] gems.
+
+=== Mapping XML
+
+If you want to use Graft in XML mode, you'll need to include the right library:
+
+    require 'rubygems'
+    require 'graft/xml'
+
+Once that is set up, you can take an XML string like this:
+
+    <rsp>
+      <user nsid="3">reagent</user>
+      <name>Patrick Reagan</name>
+    </rsp>
+
+And map it onto a Ruby class:
+
+    class User
+      include Graft
+
+      attribute :name  
+      attribute :username, :from => 'user'
+      attribute :id, :from => 'user@nsid', :type => :integer
+    end
+    
+There are a couple of ways to pull this data into the +User+ object.  The simplest
+is from the constructor:
+
+    user = User.new(xml)
+    
+There is also a +populate_from+ instance method that will do the same:
+
+    user = User.new
+    user.populate_from(xml)
+    
+This second method is useful if the data you want in your Ruby object comes from 2
+separate XML files.  Accessing it is simple:
+
+    >> user.name      # => "Patrick Reagan"
+    >> user.username  # => "reagent"
+    >> user.id        # => 3
+
+=== Mapping JSON
+
+The process of mapping JSON is similar to XML, except:
+
+* You don't need to declare the type of the attribute
+* You need to provide a full path to the JSON value
+
+To get started, include the correct library:
+
+    require 'rubygems'
+    require 'graft/json'
+    
+Then for simple JSON data:
+
+    {
+        "rsp": {
+            "user_id": 3,
+            "username": "reagent",
+            "name": "Patrick Reagan"
+        }
+    }
+
+You can map it in a similar way:
+
+    class User
+      include Graft
+  
+      attribute :name, :from => 'rsp/name'
+      attribute :username, :from => 'rsp/username'
+      attribute :id, :from => 'rsp/user_id'
+    end
+
+Again, you can initialize the values from both the constructor:
+
+    user = User.new(json)
+    
+Or the +populate_from+ method:
+
+    user = User.new
+    user.populate_from(json)
+    
+The results are the same:
+
+    >> user.name      # => "Patrick Reagan"
+    >> user.username  # => "reagent"
+    >> user.id        # => 3
+
+== License
+
+Copyright (c) 2009 Patrick Reagan (reaganpr@gmail.com)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/lib/graft/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/graft/version'
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'graft'
+  s.version          = Graft::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "Graft provides an easy way to map XML and JSON data onto your Ruby classes"
+  s.author           = 'Patrick Reagan'
+  s.email            = 'reaganpr@gmail.com'
+  s.homepage         = 'http://sneaq.net/'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib,test}/**/*")
+  
+  s.add_dependency('hpricot', '>= 0.6.164')
+  s.add_dependency('tzinfo', '>= 0.3.12')
+  s.add_dependency('builder', '>= 2.1.2')
+  s.add_dependency('activesupport', '>= 2.0')
+  s.add_dependency('json', '>= 1.1.7')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+desc 'Generate the gemspec to serve this Gem from Github'
+task :github do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/graft/lib/graft/core_ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  
+  def /(path)
+    path.to_s.split('/').inject(self) do |data, key|
+      (data.is_a?(Hash) && data[key]) ? data[key] : nil
+    end
+  end
+  
+end

data/lib/graft/lib/graft/json.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__) + '/..'
+
+require 'json'
+require 'graft/core_ext/hash'
+
+require 'graft/model'
+require 'graft/json/attribute'
+require 'graft/json/model'
+
+module Graft
+  def self.included(other)
+    other.send(:include, Graft::Json::Model)
+  end
+end

data/lib/graft/lib/graft/json/attribute.rb

@@ -0,0 +1,18 @@
+module Graft
+  module Json
+    class Attribute
+
+      attr_reader :name, :source
+
+      def initialize(name, source = nil)
+        @name   = name
+        @source = source.nil? ? @name.to_s : source
+      end
+
+      def value_from(data)
+        data/source
+      end
+
+    end
+  end
+end

data/lib/graft/lib/graft/json/model.rb

@@ -0,0 +1,28 @@
+module Graft
+  module Json
+    module Model
+
+      module ClassMethods
+
+        def attribute(name, options = {})
+          source = options[:from]
+
+          self.attributes << Graft::Json::Attribute.new(name, source)
+          class_eval "attr_accessor :#{name}"
+        end
+        
+        def data_from(json_or_hash)
+          json_or_hash.is_a?(String) ? JSON.parse(json_or_hash) : json_or_hash
+        end
+
+      end
+
+      def self.included(other)
+        other.send(:extend, Graft::Model::ClassMethods)
+        other.send(:extend, Graft::Json::Model::ClassMethods)
+        other.send(:include, Graft::Model::InstanceMethods)
+      end
+
+    end
+  end
+end

data/lib/graft/lib/graft/model.rb

@@ -0,0 +1,43 @@
+module Graft
+  module Model
+
+    module ClassMethods
+      def attributes
+        @attributes ||= []
+      end
+      
+      def collection_from(data_source, node)
+        (data_from(data_source)/node).map {|n| new n }
+      end
+
+      def collection_from_block(data_source, node, &block)
+        (data_from(data_source)/node).map{|n| yield(n) }
+      end
+    end
+
+    module InstanceMethods
+      
+      def initialize(source_data = nil)
+        self.source_data = source_data
+        self.populate_from(self.source_data) unless self.source_data.nil?
+      end
+      
+      def source_data=(source_data)
+        @source_data = self.class.data_from(source_data)
+      end
+      
+      def source_data
+        @source_data
+      end
+      
+      def populate_from(data_source)
+        self.class.attributes.each do |attribute|
+          value = attribute.value_from(self.class.data_from(data_source))
+          self.send("#{attribute.name}=".to_sym, value) unless value.nil?
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/graft/lib/graft/version.rb

@@ -0,0 +1,13 @@
+module Graft
+  module Version
+    
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 1
+    
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    
+  end
+end

data/lib/graft/lib/graft/xml.rb

@@ -0,0 +1,19 @@
+$:.unshift File.dirname(__FILE__) + '/..'
+
+require 'hpricot'
+require 'builder'
+require 'tzinfo'
+
+require 'active_support/time_with_zone'
+require 'active_support/inflector'
+
+require 'graft/model'
+require 'graft/xml/type'
+require 'graft/xml/attribute'
+require 'graft/xml/model'
+
+module Graft
+  def self.included(other)
+    other.send(:include, Graft::Xml::Model)
+  end
+end

data/lib/graft/lib/graft/xml/attribute.rb

@@ -0,0 +1,55 @@
+module Graft
+  module Xml
+    class Attribute
+
+      # TODO: Refactor the location / attribute logic into a Source class
+
+      attr_reader :name, :sources
+
+      def initialize(name, type = :string, sources = nil)
+        @name = name.to_sym
+        @type = type
+
+        @sources = Array(sources)
+        @sources << @name.to_s if @sources.empty?
+      end
+
+      def type_class
+        "Graft::Xml::Type::#{@type.to_s.camelize}".constantize
+      end
+
+      def split(source)
+        location, attribute = source.split('@')
+        location = self.name.to_s if location.blank?
+
+        [location, attribute]
+      end
+
+      def node_for(document, source)
+        document.at(location(source)) || document.search("//[@#{attribute(source)}]").first
+      end
+
+      def attribute(source)
+        location, attribute = source.split('@')
+        attribute || location
+      end
+
+      def location(source)
+        split(source).first
+      end
+
+      def value_from(document)
+        values = sources.map do |source|
+          node = node_for(document, source)
+          if !node.nil?
+            possible_values = [node.attributes[attribute(source)], node.inner_text]
+            possible_values.detect {|value| !value.blank? }
+          end
+        end
+
+        type_class.new(values.compact.first).value
+      end
+
+    end
+  end
+end

data/lib/graft/lib/graft/xml/model.rb

@@ -0,0 +1,49 @@
+module Graft
+  module Xml
+    module Model
+
+      module ClassMethods
+
+        def attribute(name, options = {})
+          source = options[:from]
+          type   = options[:type] || :string
+
+          self.attributes << Graft::Xml::Attribute.new(name, type, source)
+          class_eval "attr_accessor :#{name}"
+        end
+
+        def data_from(xml_or_document)
+          xml_or_document.is_a?(String) ? Hpricot.XML(xml_or_document) : xml_or_document
+        end
+
+      end
+
+      module InstanceMethods
+
+        def to_hash
+          self.class.attributes.inject({}) {|h,a| h.merge(a.name.to_s => send(a.name)) }
+        end
+
+        def to_xml(tag_name)
+          xml = Builder::XmlMarkup.new
+          xml.instruct!
+          xml.tag! tag_name do
+            to_hash.each do |attribute, value|
+              xml.tag! attribute, value
+            end
+          end
+          xml.target!
+        end
+
+      end
+
+      def self.included(other)
+        other.send(:extend, Graft::Model::ClassMethods)
+        other.send(:extend, Graft::Xml::Model::ClassMethods)
+        other.send(:include, Graft::Model::InstanceMethods)
+        other.send(:include, Graft::Xml::Model::InstanceMethods)
+      end
+
+    end
+  end
+end