howkast 0.0.0

data/lib/howkast/ext/string.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+class String
+  def modulize
+    gsub('__','/').
+    gsub(/\/(.?)/u){ "::#{$1.upcase}" }.
+    gsub(/(?:_+|-+)([a-z])/u){ $1.upcase }.
+    gsub(/(\A|\s)([a-z])/u){ $1 + $2.upcase }
+  end
+  
+  def parse
+    rfc2822 = "(#{Time::RFC2822_DAY_NAME.join('|')}, )? \d{1,2} #{Time::RFC2822_MONTH_NAME.join('|')} \d{4,4} \d{2,2}:\d{2,2}:\d{2,2} [+-]\d{4,4}"
+    ansi    = "#{Time::RFC2822_DAY_NAME.join('|')} #{Time::RFC2822_MONTH_NAME.join('|')} +\d{1,2} \d{2,2}:\d{2,2}:\d{2,2} [A-Z]{3,3} \d{4,4}"
+    case self
+    when /^[+-]?\d+$/u
+      to_i
+    when /^[+-]?\d+\.\d+/u
+      to_f
+    when /^(true|false)$/iu
+      self =~ /^true$/iu ? true : false
+    when /^#{rfc2822}|#{ansi}$/u
+      Time.parse(self) rescue self
+    else
+      self
+    end
+  end
+end

data/lib/howkast/model.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+class Howkast::Model
+  def self.synthesize name, data
+    classname = name.modulize
+    attrdef   = Proc.new{ data.keys.each{ |field| attr_reader field } }
+    if const_defined? classname
+      klass = const_get classname
+      klass.class_eval &attrdef
+      klass
+    else
+      const_set classname, Class.new(self, &attrdef)
+    end
+  end
+
+  def initialize processor, data, &block
+    data.each do |field, value| 
+      value = if block and value.respond_to? :each
+        block[field, value]
+      elsif value.nil?
+        processor.default_for field
+      else
+        value
+      end
+      instance_variable_set :"@#{field}", self.class.parse(value)
+    end
+  end
+  
+  def instance_attributes
+    instance_variables.map{ |name| "#{name}"[1 .. -1].to_sym }
+  end
+  
+  def self.parse value
+    value.instance_of?(String) ? value.parse : value
+  end
+end

data/lib/howkast/processors/base.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Howkast::Processor
+  class Base
+    class << self
+      # The name of the processor dictates the path used to communicate to the
+      # API server. override to provide an alternate path.
+      def path
+        "#{self}".split('::').last.downcase unless "#{self}" =~ /::Base$/u
+      end
+      
+      # Override to provide a value for field when field is nil.
+      def default_for field; end
+      
+      # Override to massage args and options as needed.
+      def filter args, options; end
+      
+      # Override to process data and restructure the returned value (eg: parse
+      # data and return a Howkast::Model::Video instance). By default it 
+      # simply returns data in its 'raw' form (the Hash from HTTParty's parsed 
+      # response)
+      def parse_element data
+        data
+      end
+      
+      private
+      # Process an entry (identified by key) in data and return an Array of 
+      # model. It assumes that data[key] represents a list of like data.
+      def parse_list key, data, model = nil, &block
+        list = (data || { })[key]
+        list = [list] if list.instance_of? Hash
+        list.map do |data|
+          name  = (model || key)
+          klass = Howkast::Model.synthesize(name, data)
+          klass.new self, data, &block
+        end
+      end
+    end
+  end
+end

data/lib/howkast/processors/categories.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+#
+# Category
+# - id
+# - name
+# - parent_id
+# - permalink
+# - parents*
+# - subcategories*
+#
+module Howkast::Processor
+  class Categories < Base
+    class << self
+      def filter args, options
+        args << options.delete(:id)
+        args.compact!
+        options = { }
+      end
+      
+      def parse_element data
+        expander = ->(key, value){ expand key, value }
+        if data.has_key? 'category'
+          data  = data['category']
+          klass = Howkast::Model.synthesize('Category', data)
+          klass.new self, data, &expander
+        else
+          parse_list 'category', data['categories'], &expander
+        end
+      end
+      
+      def default_for field
+        [] if %w{ parents categories subcategories }.include? field
+      end
+      
+      private
+      def expand key, value
+        case key
+        when 'parents'
+          value['category'] = [value['category']] \
+            unless value['category'].instance_of? Array
+          parse_element 'categories' => value
+        when 'subcategories' 
+          parse_element 'categories' => value
+        else 
+          value
+        end
+      end
+    end
+  end
+end

data/lib/howkast/processors/playlists.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+#
+# Playlist
+# - created_at
+# - description
+# - id
+# - permalink
+# - playlist_thumbnail_url
+# - rating
+# - thumbnail_url
+# - title
+# - version
+# - videos*
+# - videos_count
+# - views
+#
+module Howkast::Processor
+  class Playlists < Base
+    class << self
+      def filter args, options
+        args << options.delete(:id)
+        args.compact!
+        options = { }
+      end
+      
+      def parse_element data
+        expander = ->(key, value){ expand key, value }
+        if data.has_key? 'playlists'
+          parse_list 'playlist', data['playlists'], &expander
+        else
+          klass = Howkast::Model.synthesize('Playlist', data)
+          klass.new self, data, &expander
+        end
+      end
+      
+      def default_for field
+        [] if %w{ playlists videos }.include? field
+      end
+      
+      private
+      def expand key, value
+        case key
+        when 'playlists'
+          Playlists.parse_element 'playlists' => value
+        when 'videos'
+          Videos.parse_element 'videos' => value
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/howkast/processors/search.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+#
+# Search
+# - title
+# - videos*
+# - version
+# 
+module Howkast::Processor
+  class Search < Base
+    class << self
+      def filter args, options
+        options[:q] = options.delete(:query)
+        # HACK: The Howcast API service responds with HTTP500 error if the 
+        # :q parameter on search is an empty string - so we plug it with
+        # something that *might not* exist and hopefully it will return an 
+        # empty list :-)
+        options[:q] = '6c6d1613339399efd0bc74fe12b14dd3' if options[:q].empty?
+      end
+      
+      def parse_element data
+        expander = ->(key, value){ expand key, value }
+        klass    = Howkast::Model.synthesize('Search', data)
+        klass.new self, data, &expander
+      end
+      
+      def default_for field
+        [] if %w{ videos }.include? field
+      end
+      
+      private
+      def expand key, value
+        case key
+        when 'videos'
+          Videos.parse_element 'videos' => value
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/howkast/processors/users.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+#
+# title
+# login
+# count
+# views
+# firstname
+# lastname
+# thumbnail_url
+# videos
+# version
+#
+#created_at
+#description
+#id
+#permalink
+#rating
+#thumbnail_url
+#title
+#videos_count
+#views
+#
+module Howkast::Processor
+  class Users < Base
+    class << self
+      def filter args, options
+        args << options.delete(:id)
+        args << :profile
+        args << Array(options.delete(:resource))
+        args.compact!
+      end
+
+      def parse_element data
+        expander = ->(key, value){ expand key, value }
+        if data.has_key? 'records'
+          data['playlists'] = nil
+          data.delete 'records'
+        end
+        klass = Howkast::Model.synthesize('User', data)
+        klass.new self, data, &expander
+      end
+      
+      def default_for field
+        [] if %w{ playlists videos }.include? field
+      end
+      
+      private
+      def expand key, value
+        case key
+        when 'playlists', 'records'
+          Playlists.parse_element 'playlists' => value
+        when 'videos'
+          Videos.parse_element 'videos' => value
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/howkast/processors/videos.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+#
+# Video
+# - badges
+# - category_hierarchy*
+# - category_id
+# - comment_count
+# - comments*
+# - content_rating
+# - created_at
+# - description
+# - duration
+# - easy_steps
+# - edit_url
+# - embed
+# - filename
+# - filename  
+# - height
+# - id
+# - ingredients*
+# - markers*
+# - overlay*
+# - permalink
+# - rating
+# - related_videos*
+# - state
+# - tags
+# - thumbnail_url
+# - title
+# - type
+# - username
+# - views
+# - width
+#
+# Marker
+# - id
+# - position
+# - timemarker
+# - type
+# - thumbnail_url
+# - title
+# - textile_text
+# - text
+#
+module Howkast::Processor
+  class Videos < Base
+    class << self
+      def filter args, options
+        args << options.delete(:id)
+        args << options.delete(:sort)
+        args << options.delete(:filter)
+        args << options.delete(:category)
+        args << options.delete(:page)
+        args.compact!
+      end
+      
+      def parse_element data
+        expander = ->(key, value){ expand key, value }
+        if data.has_key? 'video'
+          data  = data['video']
+          klass = Howkast::Model.synthesize('Video', data)
+          klass.new self, data, &expander
+        else
+          parse_list 'video', data['videos'], &expander
+        end
+      end
+      
+      def default_for field
+        [] if %w{ category_hierarchy ingredients markers related_videos }.include? field
+      end
+      
+      private
+      def expand key, value
+        case key
+        when 'category_hierarchy'
+          value['category'] = case value['category']
+          when Array, String
+            Array(value['category']).map{ |category| { 'name' => category } }
+          when Hash
+            value['category']
+          end
+          Categories.parse_element 'categories' => value
+        when 'comments'
+          value['count']
+        when 'ingredients'
+          value['ingredient']
+        when 'markers'
+          parse_list 'marker', value
+        when 'related_videos'
+          parse_element 'videos' => value
+        when 'overlay'
+          klass = Howkast::Model.synthesize('Overlay', value)
+          klass.new self, value
+        else 
+          value
+        end
+      end
+    end
+  end
+end

data/sample/adhoc.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'yaml'
+begin
+  require 'howkast'
+rescue LoadError
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  require 'howkast'
+end
+
+Howkast::configure YAML.load File.read('.howkast')
+howcast = Howkast::API.new
+video   = howcast.video :id => 3907
+puts video.category_hierarchy.first.name
+
+video   = howcast.video :id => 5072
+puts video.category_hierarchy
+puts video.category_hierarchy.first.name
+
+#search  = howcast.search :query => 'jujitus'
+#puts search.videos.count
+#
+#search  = howcast.search :query => 'jujitsu'
+#puts search.videos.count
+#
+#search  = howcast.search :query => ''
+#puts search.videos.count
+#search.videos.each do |video|
+#  puts video.title
+#end